@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-control-plane-ops.ts

@@ -10,7 +10,7 @@ interface RuntimeControlPlaneOpEvent {
   readonly waitMs: number;
 }
 
-interface RuntimeControlPlaneOpsOptions {
+export interface RuntimeControlPlaneOpsOptions {
   readonly onFatal: (error: unknown) => void;
   readonly startPerfSpan: (
     name: string,
@@ -23,94 +23,43 @@ interface RuntimeControlPlaneOpsOptions {
   readonly schedule?: (callback: () => void) => void;
 }
 
-export class RuntimeControlPlaneOps {
-  private readonly opSpans = new Map<
+export interface RuntimeControlPlaneOps {
+  enqueueInteractive(task: () => Promise<void>, label?: string): void;
+  enqueueInteractiveLatest(
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label?: string,
+  ): void;
+  enqueueBackgroundLatest(
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label?: string,
+  ): void;
+  enqueueBackground(task: () => Promise<void>, label?: string): void;
+  waitForDrain(): Promise<void>;
+  metrics(): {
+    readonly interactiveQueued: number;
+    readonly backgroundQueued: number;
+    readonly running: boolean;
+  };
+}
+
+export function createRuntimeControlPlaneOps(
+  options: RuntimeControlPlaneOpsOptions,
+): RuntimeControlPlaneOps {
+  const opSpans = new Map<
     number,
     {
       end: (attrs?: PerfAttrs) => void;
     }
   >();
 
-  private readonly queue: ControlPlaneOpQueue;
-
-  constructor(private readonly options: RuntimeControlPlaneOpsOptions) {
-    this.queue = new ControlPlaneOpQueue({
-      ...(options.nowMs === undefined
-        ? {}
-        : {
-            nowMs: options.nowMs,
-          }),
-      ...(options.schedule === undefined
-        ? {}
-        : {
-            schedule: options.schedule,
-          }),
-      onFatal: (error: unknown) => {
-        this.options.onFatal(error);
-      },
-      onEnqueued: (event, metrics) => {
-        this.options.recordPerfEvent('mux.control-plane.op.enqueued', {
-          id: event.id,
-          label: event.label,
-          priority: event.priority,
-          interactiveQueued: metrics.interactiveQueued,
-          backgroundQueued: metrics.backgroundQueued,
-        });
-      },
-      onStart: (event, metrics) => {
-        const opSpan = this.options.startPerfSpan('mux.control-plane.op', {
-          id: event.id,
-          label: event.label,
-          priority: event.priority,
-          waitMs: event.waitMs,
-        });
-        this.opSpans.set(event.id, opSpan);
-        this.options.recordPerfEvent('mux.control-plane.op.start', {
-          id: event.id,
-          label: event.label,
-          priority: event.priority,
-          waitMs: event.waitMs,
-          interactiveQueued: metrics.interactiveQueued,
-          backgroundQueued: metrics.backgroundQueued,
-        });
-      },
-      onSuccess: (event) => {
-        this.endSpan(event, 'ok');
-      },
-      onError: (event, _metrics, error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        this.endSpan(event, 'error', message);
-        this.options.writeStderr(`[mux] control-plane error ${message}\n`);
-      },
-    });
-  }
-
-  enqueueInteractive(task: () => Promise<void>, label = 'interactive-op'): void {
-    this.queue.enqueueInteractive(task, label);
-  }
-
-  enqueueBackground(task: () => Promise<void>, label = 'background-op'): void {
-    this.queue.enqueueBackground(task, label);
-  }
-
-  async waitForDrain(): Promise<void> {
-    await this.queue.waitForDrain();
-  }
-
-  metrics(): {
-    readonly interactiveQueued: number;
-    readonly backgroundQueued: number;
-    readonly running: boolean;
-  } {
-    return this.queue.metrics();
-  }
-
-  private endSpan(
+  const endSpan = (
     event: RuntimeControlPlaneOpEvent,
-    status: 'ok' | 'error',
+    status: 'ok' | 'error' | 'canceled',
     message?: string,
-  ): void {
-    const opSpan = this.opSpans.get(event.id);
+  ): void => {
+    const opSpan = opSpans.get(event.id);
     if (opSpan === undefined) {
       return;
     }
@@ -126,6 +75,96 @@ export class RuntimeControlPlaneOps {
             message,
           }),
     });
-    this.opSpans.delete(event.id);
-  }
+    opSpans.delete(event.id);
+  };
+
+  const queue = new ControlPlaneOpQueue({
+    ...(options.nowMs === undefined
+      ? {}
+      : {
+          nowMs: options.nowMs,
+        }),
+    ...(options.schedule === undefined
+      ? {}
+      : {
+          schedule: options.schedule,
+        }),
+    onFatal: (error: unknown) => {
+      options.onFatal(error);
+    },
+    onEnqueued: (event, metrics) => {
+      options.recordPerfEvent('mux.control-plane.op.enqueued', {
+        id: event.id,
+        label: event.label,
+        priority: event.priority,
+        interactiveQueued: metrics.interactiveQueued,
+        backgroundQueued: metrics.backgroundQueued,
+      });
+    },
+    onStart: (event, metrics) => {
+      const opSpan = options.startPerfSpan('mux.control-plane.op', {
+        id: event.id,
+        label: event.label,
+        priority: event.priority,
+        waitMs: event.waitMs,
+      });
+      opSpans.set(event.id, opSpan);
+      options.recordPerfEvent('mux.control-plane.op.start', {
+        id: event.id,
+        label: event.label,
+        priority: event.priority,
+        waitMs: event.waitMs,
+        interactiveQueued: metrics.interactiveQueued,
+        backgroundQueued: metrics.backgroundQueued,
+      });
+    },
+    onSuccess: (event) => {
+      endSpan(event, 'ok');
+    },
+    onError: (event, _metrics, error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      endSpan(event, 'error', message);
+      options.writeStderr(`[mux] control-plane error ${message}\n`);
+    },
+    onCanceled: (event) => {
+      endSpan(event, 'canceled');
+    },
+  });
+
+  return {
+    enqueueInteractive: (task: () => Promise<void>, label = 'interactive-op'): void => {
+      queue.enqueueInteractive(async () => {
+        await task();
+      }, label);
+    },
+    enqueueInteractiveLatest: (
+      key: string,
+      task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+      label = 'interactive-op',
+    ): void => {
+      queue.enqueueInteractive(task, label, {
+        key,
+        supersede: 'pending-and-running',
+      });
+    },
+    enqueueBackgroundLatest: (
+      key: string,
+      task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+      label = 'background-op',
+    ): void => {
+      queue.enqueueBackground(task, label, {
+        key,
+        supersede: 'pending-and-running',
+      });
+    },
+    enqueueBackground: (task: () => Promise<void>, label = 'background-op'): void => {
+      queue.enqueueBackground(async () => {
+        await task();
+      }, label);
+    },
+    waitForDrain: async (): Promise<void> => {
+      await queue.waitForDrain();
+    },
+    metrics: () => queue.metrics(),
+  };
 }

package/src/services/runtime-conversation-actions.ts

@@ -52,19 +52,25 @@ export interface RuntimeConversationActionsOptions<TControllerRecord> {
   readonly markDirty: () => void;
 }
 
-export class RuntimeConversationActions<TControllerRecord> {
-  constructor(private readonly options: RuntimeConversationActionsOptions<TControllerRecord>) {}
+export interface RuntimeConversationActions {
+  createAndActivateConversationInDirectory(directoryId: string, agentType: string): Promise<void>;
+  openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void>;
+  takeoverConversation(sessionId: string): Promise<void>;
+}
 
-  async createAndActivateConversationInDirectory(
+export function createRuntimeConversationActions<TControllerRecord>(
+  options: RuntimeConversationActionsOptions<TControllerRecord>,
+): RuntimeConversationActions {
+  const createAndActivateConversationInDirectory = async (
     directoryId: string,
     agentType: string,
-  ): Promise<void> {
+  ): Promise<void> => {
     await createAndActivateConversationInDirectoryFn({
       directoryId,
       agentType,
-      createConversationId: this.options.createConversationId,
+      createConversationId: options.createConversationId,
       createConversationRecord: async (sessionId, targetDirectoryId, targetAgentType) => {
-        await this.options.controlPlaneService.createConversation({
+        await options.controlPlaneService.createConversation({
           conversationId: sessionId,
           directoryId: targetDirectoryId,
           title: '',
@@ -72,42 +78,50 @@ export class RuntimeConversationActions<TControllerRecord> {
           adapterState: {},
         });
       },
-      ensureConversation: this.options.ensureConversation,
-      noteGitActivity: this.options.noteGitActivity,
-      startConversation: this.options.startConversation,
-      activateConversation: this.options.activateConversation,
+      ensureConversation: options.ensureConversation,
+      noteGitActivity: options.noteGitActivity,
+      startConversation: options.startConversation,
+      activateConversation: options.activateConversation,
     });
-  }
+  };
 
-  async openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void> {
+  const openOrCreateCritiqueConversationInDirectory = async (
+    directoryId: string,
+  ): Promise<void> => {
     await openOrCreateCritiqueConversationInDirectoryFn({
       directoryId,
-      orderedConversationIds: this.options.orderedConversationIds,
-      conversationById: this.options.conversationById,
-      activateConversation: this.options.activateConversation,
+      orderedConversationIds: options.orderedConversationIds,
+      conversationById: options.conversationById,
+      activateConversation: options.activateConversation,
       createAndActivateCritiqueConversationInDirectory: async (targetDirectoryId) => {
-        await this.createAndActivateConversationInDirectory(targetDirectoryId, 'critique');
+        await createAndActivateConversationInDirectory(targetDirectoryId, 'critique');
       },
     });
-  }
+  };
 
-  async takeoverConversation(sessionId: string): Promise<void> {
+  const takeoverConversation = async (sessionId: string): Promise<void> => {
     await takeoverConversationFn({
       sessionId,
-      conversationsHas: this.options.conversationsHas,
+      conversationsHas: options.conversationsHas,
       claimSession: async (targetSessionId) => {
-        return await this.options.controlPlaneService.claimSession({
+        return await options.controlPlaneService.claimSession({
           sessionId: targetSessionId,
-          controllerId: this.options.muxControllerId,
+          controllerId: options.muxControllerId,
           controllerType: 'human',
-          controllerLabel: this.options.muxControllerLabel,
+          controllerLabel: options.muxControllerLabel,
           reason: 'human takeover',
           takeover: true,
         });
       },
-      applyController: this.options.applyController,
-      setLastEventNow: this.options.setLastEventNow,
-      markDirty: this.options.markDirty,
+      applyController: options.applyController,
+      setLastEventNow: options.setLastEventNow,
+      markDirty: options.markDirty,
     });
-  }
+  };
+
+  return {
+    createAndActivateConversationInDirectory,
+    openOrCreateCritiqueConversationInDirectory,
+    takeoverConversation,
+  };
 }

package/src/services/runtime-conversation-activation.ts

@@ -24,55 +24,107 @@ export interface RuntimeConversationActivationOptions {
   readonly markDirty: () => void;
 }
 
-export class RuntimeConversationActivation {
-  constructor(private readonly options: RuntimeConversationActivationOptions) {}
+export interface RuntimeConversationActivation {
+  activateConversation(sessionId: string, input?: { readonly signal?: AbortSignal }): Promise<void>;
+}
 
-  async activateConversation(sessionId: string): Promise<void> {
-    if (this.options.getActiveConversationId() === sessionId) {
-      if (!this.options.isConversationPaneMode()) {
-        this.options.enterConversationPaneForActiveSession(sessionId);
-        this.options.markDirty();
+export function createRuntimeConversationActivation(
+  options: RuntimeConversationActivationOptions,
+): RuntimeConversationActivation {
+  async function attachConversationWithRecovery(
+    sessionId: string,
+    signal: AbortSignal | undefined,
+  ): Promise<boolean> {
+    try {
+      await options.attachConversation(sessionId);
+      return !(signal?.aborted ?? false);
+    } catch (error: unknown) {
+      if (!options.isSessionNotFoundError(error) && !options.isSessionNotLiveError(error)) {
+        throw error;
+      }
+      options.markSessionUnavailable(sessionId);
+      await options.startConversation(sessionId);
+      if (signal?.aborted) {
+        return false;
+      }
+      await options.attachConversation(sessionId);
+      return !(signal?.aborted ?? false);
+    }
+  }
+
+  async function activateConversation(
+    sessionId: string,
+    input: { readonly signal?: AbortSignal } = {},
+  ): Promise<void> {
+    const signal = input.signal;
+    if (signal?.aborted) {
+      return;
+    }
+    if (options.getActiveConversationId() === sessionId) {
+      if (!options.isConversationPaneMode()) {
+        const targetConversation = options.conversationById(sessionId);
+        if (
+          targetConversation !== undefined &&
+          !targetConversation.live &&
+          targetConversation.status !== 'exited'
+        ) {
+          await options.startConversation(sessionId);
+          if (signal?.aborted) {
+            return;
+          }
+        }
+        if (targetConversation?.status !== 'exited') {
+          const attached = await attachConversationWithRecovery(sessionId, signal);
+          if (!attached) {
+            return;
+          }
+        }
+        options.enterConversationPaneForActiveSession(sessionId);
+        options.noteGitActivity(targetConversation?.directoryId ?? null);
+        options.schedulePtyResizeImmediate();
+        options.markDirty();
       }
       return;
     }
 
-    this.options.stopConversationTitleEditForOtherSession(sessionId);
-    const previousActiveId = this.options.getActiveConversationId();
-    this.options.clearSelectionState();
+    options.stopConversationTitleEditForOtherSession(sessionId);
+    const previousActiveId = options.getActiveConversationId();
+    options.clearSelectionState();
     if (previousActiveId !== null) {
-      await this.options.detachConversation(previousActiveId);
+      await options.detachConversation(previousActiveId);
+      if (signal?.aborted) {
+        return;
+      }
     }
-    this.options.setActiveConversationId(sessionId);
-    this.options.enterConversationPaneForSessionSwitch(sessionId);
 
-    const targetConversation = this.options.conversationById(sessionId);
-    this.options.noteGitActivity(targetConversation?.directoryId ?? null);
+    const targetConversation = options.conversationById(sessionId);
 
     if (
       targetConversation !== undefined &&
       !targetConversation.live &&
       targetConversation.status !== 'exited'
     ) {
-      await this.options.startConversation(sessionId);
+      await options.startConversation(sessionId);
+      if (signal?.aborted) {
+        return;
+      }
     }
 
     if (targetConversation?.status !== 'exited') {
-      try {
-        await this.options.attachConversation(sessionId);
-      } catch (error: unknown) {
-        if (
-          !this.options.isSessionNotFoundError(error) &&
-          !this.options.isSessionNotLiveError(error)
-        ) {
-          throw error;
-        }
-        this.options.markSessionUnavailable(sessionId);
-        await this.options.startConversation(sessionId);
-        await this.options.attachConversation(sessionId);
+      const attached = await attachConversationWithRecovery(sessionId, signal);
+      if (!attached) {
+        return;
       }
     }
 
-    this.options.schedulePtyResizeImmediate();
-    this.options.markDirty();
+    options.setActiveConversationId(sessionId);
+    options.enterConversationPaneForSessionSwitch(sessionId);
+    options.noteGitActivity(targetConversation?.directoryId ?? null);
+    options.schedulePtyResizeImmediate();
+    options.markDirty();
   }
+
+  return {
+    activateConversation,
+  };
 }

package/src/services/runtime-conversation-starter.ts

@@ -33,6 +33,13 @@ interface RuntimeConversationStarterLaunchArgsInput {
 
 type RuntimeConversationStarterSpanAttributes = Record<string, string | number | boolean>;
 
+function isSessionAlreadyExistsError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes('session already exists');
+}
+
 export interface RuntimeConversationStarterOptions<
   TConversation extends RuntimeConversationStarterConversationRecord,
   TSessionSummary,
@@ -76,82 +83,113 @@ export interface RuntimeConversationStarterOptions<
   readonly subscribeConversationEvents: (sessionId: string) => Promise<void>;
 }
 
-export class RuntimeConversationStarter<
+export interface RuntimeConversationStarter<
   TConversation extends RuntimeConversationStarterConversationRecord,
-  TSessionSummary,
 > {
-  constructor(
-    private readonly options: RuntimeConversationStarterOptions<TConversation, TSessionSummary>,
-  ) {}
+  startConversation(sessionId: string): Promise<TConversation>;
+}
+
+export function createRuntimeConversationStarter<
+  TConversation extends RuntimeConversationStarterConversationRecord,
+  TSessionSummary,
+>(
+  options: RuntimeConversationStarterOptions<TConversation, TSessionSummary>,
+): RuntimeConversationStarter<TConversation> {
+  function endStartCommandSpanIfTarget(
+    sessionId: string,
+    payload: RuntimeConversationStarterSpanAttributes,
+  ): void {
+    if (options.firstPaintTargetSessionId() !== sessionId) {
+      return;
+    }
+    options.endStartCommandSpan(payload);
+  }
 
-  async startConversation(sessionId: string): Promise<TConversation> {
-    return await this.options.runWithStartInFlight(sessionId, async () => {
-      const existing = this.options.conversationById(sessionId);
-      const targetConversation = existing ?? this.options.ensureConversation(sessionId);
-      const agentType = this.options.normalizeThreadAgentType(targetConversation.agentType);
+  async function startConversation(sessionId: string): Promise<TConversation> {
+    return await options.runWithStartInFlight(sessionId, async () => {
+      const existing = options.conversationById(sessionId);
+      const targetConversation = existing ?? options.ensureConversation(sessionId);
+      const agentType = options.normalizeThreadAgentType(targetConversation.agentType);
       const baseArgsForAgent =
         agentType === 'codex'
-          ? this.options.codexArgs
+          ? options.codexArgs
           : agentType === 'critique'
-            ? this.options.critiqueDefaultArgs
+            ? options.critiqueDefaultArgs
             : [];
-      const sessionCwd = this.options.sessionCwdForConversation(targetConversation);
-      const launchArgs = this.options.buildLaunchArgs({
+      const sessionCwd = options.sessionCwdForConversation(targetConversation);
+      const launchArgs = options.buildLaunchArgs({
         agentType,
         baseArgsForAgent,
         adapterState: targetConversation.adapterState,
         sessionCwd,
       });
-      targetConversation.launchCommand = this.options.formatCommandForDebugBar(
-        this.options.launchCommandForAgent(agentType),
+      targetConversation.launchCommand = options.formatCommandForDebugBar(
+        options.launchCommandForAgent(agentType),
         launchArgs,
       );
 
       if (existing?.live === true) {
-        this.endStartCommandSpanIfTarget(sessionId, {
+        endStartCommandSpanIfTarget(sessionId, {
           alreadyLive: true,
         });
         return existing;
       }
 
-      const startSpan = this.options.startConversationSpan(sessionId);
+      const startSpan = options.startConversationSpan(sessionId);
       targetConversation.lastOutputCursor = 0;
-      const layout = this.options.layout();
+      const layout = options.layout();
       const ptyStartInput: RuntimeConversationStarterPtyStartInput = {
         sessionId,
         args: launchArgs,
-        env: this.options.sessionEnv,
+        env: options.sessionEnv,
         cwd: sessionCwd,
         initialCols: layout.rightCols,
         initialRows: layout.paneRows,
       };
-      if (this.options.worktreeId !== undefined) {
-        ptyStartInput.worktreeId = this.options.worktreeId;
+      if (options.worktreeId !== undefined) {
+        ptyStartInput.worktreeId = options.worktreeId;
       }
-      if (this.options.terminalForegroundHex !== undefined) {
-        ptyStartInput.terminalForegroundHex = this.options.terminalForegroundHex;
+      if (options.terminalForegroundHex !== undefined) {
+        ptyStartInput.terminalForegroundHex = options.terminalForegroundHex;
       }
-      if (this.options.terminalBackgroundHex !== undefined) {
-        ptyStartInput.terminalBackgroundHex = this.options.terminalBackgroundHex;
+      if (options.terminalBackgroundHex !== undefined) {
+        ptyStartInput.terminalBackgroundHex = options.terminalBackgroundHex;
       }
-      await this.options.startPtySession(ptyStartInput);
-      this.options.setPtySize(sessionId, {
+      let startedSession = false;
+      try {
+        await options.startPtySession(ptyStartInput);
+        startedSession = true;
+      } catch (error: unknown) {
+        if (!isSessionAlreadyExistsError(error)) {
+          throw error;
+        }
+      }
+      options.setPtySize(sessionId, {
         cols: layout.rightCols,
         rows: layout.paneRows,
       });
-      this.options.sendResize(sessionId, layout.rightCols, layout.paneRows);
-      this.endStartCommandSpanIfTarget(sessionId, {
-        alreadyLive: false,
-        argCount: launchArgs.length,
-        resumed: launchArgs[0] === 'resume',
-      });
-      const state = this.options.ensureConversation(sessionId);
-      this.options.recordStartCommand(sessionId, launchArgs);
-      const statusSummary = await this.options.getSessionStatus(sessionId);
+      options.sendResize(sessionId, layout.rightCols, layout.paneRows);
+      if (startedSession) {
+        endStartCommandSpanIfTarget(sessionId, {
+          alreadyLive: false,
+          argCount: launchArgs.length,
+          resumed: launchArgs[0] === 'resume',
+        });
+      } else {
+        endStartCommandSpanIfTarget(sessionId, {
+          alreadyLive: true,
+          recoveredDuplicateStart: true,
+        });
+      }
+      const state = options.ensureConversation(sessionId);
+      if (startedSession) {
+        options.recordStartCommand(sessionId, launchArgs);
+      }
+      const statusSummary = await options.getSessionStatus(sessionId);
       if (statusSummary !== null) {
-        this.options.upsertFromSessionSummary(statusSummary);
+        options.upsertFromSessionSummary(statusSummary);
       }
-      await this.options.subscribeConversationEvents(sessionId);
+      await options.subscribeConversationEvents(sessionId);
       startSpan.end({
         live: state.live,
       });
@@ -159,13 +197,7 @@ export class RuntimeConversationStarter<
     });
   }
 
-  private endStartCommandSpanIfTarget(
-    sessionId: string,
-    payload: RuntimeConversationStarterSpanAttributes,
-  ): void {
-    if (this.options.firstPaintTargetSessionId() !== sessionId) {
-      return;
-    }
-    this.options.endStartCommandSpan(payload);
-  }
+  return {
+    startConversation,
+  };
 }