@jmoyers/harness 0.1.0

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

@@ -0,0 +1,78 @@
+interface RuntimeActivationConversationRecord {
+  readonly directoryId: string | null;
+  readonly live: boolean;
+  readonly status: string;
+}
+
+export interface RuntimeConversationActivationOptions {
+  readonly getActiveConversationId: () => string | null;
+  readonly setActiveConversationId: (sessionId: string) => void;
+  readonly isConversationPaneMode: () => boolean;
+  readonly enterConversationPaneForActiveSession: (sessionId: string) => void;
+  readonly enterConversationPaneForSessionSwitch: (sessionId: string) => void;
+  readonly stopConversationTitleEditForOtherSession: (sessionId: string) => void;
+  readonly clearSelectionState: () => void;
+  readonly detachConversation: (sessionId: string) => Promise<void>;
+  readonly conversationById: (sessionId: string) => RuntimeActivationConversationRecord | undefined;
+  readonly noteGitActivity: (directoryId: string | null) => void;
+  readonly startConversation: (sessionId: string) => Promise<unknown>;
+  readonly attachConversation: (sessionId: string) => Promise<void>;
+  readonly isSessionNotFoundError: (error: unknown) => boolean;
+  readonly isSessionNotLiveError: (error: unknown) => boolean;
+  readonly markSessionUnavailable: (sessionId: string) => void;
+  readonly schedulePtyResizeImmediate: () => void;
+  readonly markDirty: () => void;
+}
+
+export class RuntimeConversationActivation {
+  constructor(private readonly options: RuntimeConversationActivationOptions) {}
+
+  async activateConversation(sessionId: string): Promise<void> {
+    if (this.options.getActiveConversationId() === sessionId) {
+      if (!this.options.isConversationPaneMode()) {
+        this.options.enterConversationPaneForActiveSession(sessionId);
+        this.options.markDirty();
+      }
+      return;
+    }
+
+    this.options.stopConversationTitleEditForOtherSession(sessionId);
+    const previousActiveId = this.options.getActiveConversationId();
+    this.options.clearSelectionState();
+    if (previousActiveId !== null) {
+      await this.options.detachConversation(previousActiveId);
+    }
+    this.options.setActiveConversationId(sessionId);
+    this.options.enterConversationPaneForSessionSwitch(sessionId);
+
+    const targetConversation = this.options.conversationById(sessionId);
+    this.options.noteGitActivity(targetConversation?.directoryId ?? null);
+
+    if (
+      targetConversation !== undefined &&
+      !targetConversation.live &&
+      targetConversation.status !== 'exited'
+    ) {
+      await this.options.startConversation(sessionId);
+    }
+
+    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);
+      }
+    }
+
+    this.options.schedulePtyResizeImmediate();
+    this.options.markDirty();
+  }
+}

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

@@ -0,0 +1,171 @@
+export interface RuntimeConversationStarterConversationRecord {
+  readonly sessionId: string;
+  readonly directoryId: string | null;
+  readonly agentType: string;
+  adapterState: Record<string, unknown>;
+  live: boolean;
+  lastOutputCursor: number;
+  launchCommand: string | null;
+}
+
+interface RuntimeConversationStarterPerfSpan {
+  end(input?: Record<string, unknown>): void;
+}
+
+interface RuntimeConversationStarterPtyStartInput {
+  sessionId: string;
+  args: readonly string[];
+  env: Record<string, string>;
+  cwd: string;
+  initialCols: number;
+  initialRows: number;
+  worktreeId?: string;
+  terminalForegroundHex?: string;
+  terminalBackgroundHex?: string;
+}
+
+interface RuntimeConversationStarterLaunchArgsInput {
+  readonly agentType: string;
+  readonly baseArgsForAgent: readonly string[];
+  readonly adapterState: Record<string, unknown>;
+  readonly sessionCwd: string;
+}
+
+type RuntimeConversationStarterSpanAttributes = Record<string, string | number | boolean>;
+
+export interface RuntimeConversationStarterOptions<
+  TConversation extends RuntimeConversationStarterConversationRecord,
+  TSessionSummary,
+> {
+  readonly runWithStartInFlight: (
+    sessionId: string,
+    run: () => Promise<TConversation>,
+  ) => Promise<TConversation>;
+  readonly conversationById: (sessionId: string) => TConversation | undefined;
+  readonly ensureConversation: (sessionId: string) => TConversation;
+  readonly normalizeThreadAgentType: (agentType: string) => string;
+  readonly codexArgs: readonly string[];
+  readonly critiqueDefaultArgs: readonly string[];
+  readonly sessionCwdForConversation: (conversation: TConversation) => string;
+  readonly buildLaunchArgs: (input: RuntimeConversationStarterLaunchArgsInput) => readonly string[];
+  readonly launchCommandForAgent: (agentType: string) => string;
+  readonly formatCommandForDebugBar: (command: string, args: readonly string[]) => string;
+  readonly startConversationSpan: (sessionId: string) => RuntimeConversationStarterPerfSpan;
+  readonly firstPaintTargetSessionId: () => string | null;
+  readonly endStartCommandSpan: (input: RuntimeConversationStarterSpanAttributes) => void;
+  readonly layout: () => {
+    rightCols: number;
+    paneRows: number;
+  };
+  readonly startPtySession: (input: RuntimeConversationStarterPtyStartInput) => Promise<void>;
+  readonly setPtySize: (
+    sessionId: string,
+    size: {
+      cols: number;
+      rows: number;
+    },
+  ) => void;
+  readonly sendResize: (sessionId: string, cols: number, rows: number) => void;
+  readonly sessionEnv: Record<string, string>;
+  readonly worktreeId: string | undefined;
+  readonly terminalForegroundHex: string | undefined;
+  readonly terminalBackgroundHex: string | undefined;
+  readonly recordStartCommand: (sessionId: string, launchArgs: readonly string[]) => void;
+  readonly getSessionStatus: (sessionId: string) => Promise<TSessionSummary | null>;
+  readonly upsertFromSessionSummary: (summary: TSessionSummary) => void;
+  readonly subscribeConversationEvents: (sessionId: string) => Promise<void>;
+}
+
+export class RuntimeConversationStarter<
+  TConversation extends RuntimeConversationStarterConversationRecord,
+  TSessionSummary,
+> {
+  constructor(
+    private readonly options: RuntimeConversationStarterOptions<TConversation, TSessionSummary>,
+  ) {}
+
+  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);
+      const baseArgsForAgent =
+        agentType === 'codex'
+          ? this.options.codexArgs
+          : agentType === 'critique'
+            ? this.options.critiqueDefaultArgs
+            : [];
+      const sessionCwd = this.options.sessionCwdForConversation(targetConversation);
+      const launchArgs = this.options.buildLaunchArgs({
+        agentType,
+        baseArgsForAgent,
+        adapterState: targetConversation.adapterState,
+        sessionCwd,
+      });
+      targetConversation.launchCommand = this.options.formatCommandForDebugBar(
+        this.options.launchCommandForAgent(agentType),
+        launchArgs,
+      );
+
+      if (existing?.live === true) {
+        this.endStartCommandSpanIfTarget(sessionId, {
+          alreadyLive: true,
+        });
+        return existing;
+      }
+
+      const startSpan = this.options.startConversationSpan(sessionId);
+      targetConversation.lastOutputCursor = 0;
+      const layout = this.options.layout();
+      const ptyStartInput: RuntimeConversationStarterPtyStartInput = {
+        sessionId,
+        args: launchArgs,
+        env: this.options.sessionEnv,
+        cwd: sessionCwd,
+        initialCols: layout.rightCols,
+        initialRows: layout.paneRows,
+      };
+      if (this.options.worktreeId !== undefined) {
+        ptyStartInput.worktreeId = this.options.worktreeId;
+      }
+      if (this.options.terminalForegroundHex !== undefined) {
+        ptyStartInput.terminalForegroundHex = this.options.terminalForegroundHex;
+      }
+      if (this.options.terminalBackgroundHex !== undefined) {
+        ptyStartInput.terminalBackgroundHex = this.options.terminalBackgroundHex;
+      }
+      await this.options.startPtySession(ptyStartInput);
+      this.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);
+      if (statusSummary !== null) {
+        this.options.upsertFromSessionSummary(statusSummary);
+      }
+      await this.options.subscribeConversationEvents(sessionId);
+      startSpan.end({
+        live: state.live,
+      });
+      return state;
+    });
+  }
+
+  private endStartCommandSpanIfTarget(
+    sessionId: string,
+    payload: RuntimeConversationStarterSpanAttributes,
+  ): void {
+    if (this.options.firstPaintTargetSessionId() !== sessionId) {
+      return;
+    }
+    this.options.endStartCommandSpan(payload);
+  }
+}

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

@@ -0,0 +1,149 @@
+import type { ConversationTitleEditState, WorkspaceModel } from '../domain/workspace.ts';
+
+interface ConversationTitleRecordLike {
+  title: string;
+}
+
+export interface RuntimeConversationTitleEditServiceOptions<
+  TConversation extends ConversationTitleRecordLike,
+> {
+  readonly workspace: WorkspaceModel;
+  readonly updateConversationTitle: (input: {
+    conversationId: string;
+    title: string;
+  }) => Promise<{ title: string } | null>;
+  readonly conversationById: (conversationId: string) => TConversation | undefined;
+  readonly markDirty: () => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly debounceMs: number;
+  readonly setDebounceTimer?: (callback: () => void, ms: number) => NodeJS.Timeout;
+  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();
+  }
+
+  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();
+  }
+
+  private clearTimer(edit: ConversationTitleEditState): void {
+    if (edit.debounceTimer !== null) {
+      this.clearDebounceTimer(edit.debounceTimer);
+      edit.debounceTimer = null;
+    }
+  }
+
+  private 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 () => {
+      try {
+        const parsed = await this.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 shouldApplyToConversation =
+          latestEdit === null ||
+          latestEdit.conversationId !== edit.conversationId ||
+          latestEdit.value === titleToPersist;
+        if (latestConversation !== undefined && shouldApplyToConversation) {
+          latestConversation.title = persistedTitle;
+        }
+        if (latestEdit !== null && latestEdit.conversationId === edit.conversationId) {
+          latestEdit.lastSavedValue = persistedTitle;
+          if (latestEdit.value === titleToPersist) {
+            latestEdit.error = null;
+          }
+        }
+      } catch (error: unknown) {
+        const latestEdit = this.options.workspace.conversationTitleEdit;
+        if (
+          latestEdit !== null &&
+          latestEdit.conversationId === edit.conversationId &&
+          latestEdit.value === titleToPersist
+        ) {
+          latestEdit.error = error instanceof Error ? error.message : String(error);
+        }
+        throw error;
+      } finally {
+        const latestEdit = this.options.workspace.conversationTitleEdit;
+        if (latestEdit !== null && latestEdit.conversationId === edit.conversationId) {
+          latestEdit.persistInFlight = false;
+        }
+        this.options.markDirty();
+      }
+    }, `title-edit-${reason}:${edit.conversationId}`);
+  }
+}

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

@@ -0,0 +1,164 @@
+import {
+  addDirectoryByPath as addDirectoryByPathFn,
+  archiveConversation as archiveConversationFn,
+  closeDirectory as closeDirectoryFn,
+} from '../mux/live-mux/actions-conversation.ts';
+
+interface RuntimeConversationStateLike {
+  readonly directoryId: string | null;
+  readonly live: boolean;
+}
+
+interface RuntimeDirectoryRecordLike {
+  readonly directoryId: string;
+}
+
+interface RuntimeDirectoryActionService<TDirectoryRecord extends RuntimeDirectoryRecordLike> {
+  closePtySession(sessionId: string): Promise<unknown>;
+  removeSession(sessionId: string): Promise<unknown>;
+  archiveConversation(sessionId: string): Promise<unknown>;
+  upsertDirectory(input: { directoryId: string; path: string }): Promise<TDirectoryRecord | null>;
+  archiveDirectory(directoryId: string): Promise<unknown>;
+}
+
+interface RuntimeDirectoryActionsOptions<
+  TDirectoryRecord extends RuntimeDirectoryRecordLike,
+  TConversationState extends RuntimeConversationStateLike,
+> {
+  readonly controlPlaneService: RuntimeDirectoryActionService<TDirectoryRecord>;
+  readonly conversations: () => ReadonlyMap<string, TConversationState>;
+  readonly orderedConversationIds: () => readonly string[];
+  readonly conversationDirectoryId: (sessionId: string) => string | null;
+  readonly conversationLive: (sessionId: string) => boolean;
+  readonly removeConversationState: (sessionId: string) => void;
+  readonly unsubscribeConversationEvents: (sessionId: string) => Promise<void>;
+  readonly activeConversationId: () => string | null;
+  readonly setActiveConversationId: (sessionId: string | null) => void;
+  readonly activateConversation: (sessionId: string) => Promise<unknown>;
+  readonly resolveActiveDirectoryId: () => string | null;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly markDirty: () => void;
+  readonly isSessionNotFoundError: (error: unknown) => boolean;
+  readonly isConversationNotFoundError: (error: unknown) => boolean;
+  readonly createDirectoryId: () => string;
+  readonly resolveWorkspacePathForMux: (rawPath: string) => string;
+  readonly setDirectory: (directory: TDirectoryRecord) => void;
+  readonly directoryIdOf: (directory: TDirectoryRecord) => string;
+  readonly setActiveDirectoryId: (directoryId: string | null) => void;
+  readonly syncGitStateWithDirectories: () => void;
+  readonly noteGitActivity: (directoryId: string) => void;
+  readonly hydratePersistedConversationsForDirectory: (directoryId: string) => Promise<unknown>;
+  readonly findConversationIdByDirectory: (directoryId: string) => string | null;
+  readonly directoriesHas: (directoryId: string) => boolean;
+  readonly deleteDirectory: (directoryId: string) => void;
+  readonly deleteDirectoryGitState: (directoryId: string) => void;
+  readonly projectPaneSnapshotDirectoryId: () => string | null;
+  readonly clearProjectPaneSnapshot: () => void;
+  readonly directoriesSize: () => number;
+  readonly invocationDirectory: string;
+  readonly activeDirectoryId: () => string | null;
+  readonly firstDirectoryId: () => string | null;
+}
+
+export class RuntimeDirectoryActions<
+  TDirectoryRecord extends RuntimeDirectoryRecordLike,
+  TConversationState extends RuntimeConversationStateLike,
+> {
+  constructor(
+    private readonly options: RuntimeDirectoryActionsOptions<TDirectoryRecord, TConversationState>,
+  ) {}
+
+  async archiveConversation(sessionId: string): Promise<void> {
+    await archiveConversationFn({
+      sessionId,
+      conversations: this.options.conversations(),
+      closePtySession: async (targetSessionId) => {
+        await this.options.controlPlaneService.closePtySession(targetSessionId);
+      },
+      removeSession: async (targetSessionId) => {
+        await this.options.controlPlaneService.removeSession(targetSessionId);
+      },
+      isSessionNotFoundError: this.options.isSessionNotFoundError,
+      archiveConversationRecord: async (targetSessionId) => {
+        await this.options.controlPlaneService.archiveConversation(targetSessionId);
+      },
+      isConversationNotFoundError: this.options.isConversationNotFoundError,
+      unsubscribeConversationEvents: this.options.unsubscribeConversationEvents,
+      removeConversationState: this.options.removeConversationState,
+      activeConversationId: this.options.activeConversationId(),
+      setActiveConversationId: this.options.setActiveConversationId,
+      orderedConversationIds: this.options.orderedConversationIds,
+      conversationDirectoryId: this.options.conversationDirectoryId,
+      resolveActiveDirectoryId: this.options.resolveActiveDirectoryId,
+      enterProjectPane: this.options.enterProjectPane,
+      activateConversation: this.options.activateConversation,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  async addDirectoryByPath(rawPath: string): Promise<void> {
+    await addDirectoryByPathFn({
+      rawPath,
+      resolveWorkspacePathForMux: this.options.resolveWorkspacePathForMux,
+      upsertDirectory: async (path) => {
+        return await this.options.controlPlaneService.upsertDirectory({
+          directoryId: this.options.createDirectoryId(),
+          path,
+        });
+      },
+      setDirectory: this.options.setDirectory,
+      directoryIdOf: this.options.directoryIdOf,
+      setActiveDirectoryId: (directoryId) => {
+        this.options.setActiveDirectoryId(directoryId);
+      },
+      syncGitStateWithDirectories: this.options.syncGitStateWithDirectories,
+      noteGitActivity: this.options.noteGitActivity,
+      hydratePersistedConversationsForDirectory:
+        this.options.hydratePersistedConversationsForDirectory,
+      findConversationIdByDirectory: this.options.findConversationIdByDirectory,
+      activateConversation: this.options.activateConversation,
+      enterProjectPane: this.options.enterProjectPane,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  async closeDirectory(directoryId: string): Promise<void> {
+    await closeDirectoryFn({
+      directoryId,
+      directoriesHas: this.options.directoriesHas,
+      orderedConversationIds: this.options.orderedConversationIds,
+      conversationDirectoryId: this.options.conversationDirectoryId,
+      conversationLive: this.options.conversationLive,
+      closePtySession: async (sessionId) => {
+        await this.options.controlPlaneService.closePtySession(sessionId);
+      },
+      archiveConversationRecord: async (sessionId) => {
+        await this.options.controlPlaneService.archiveConversation(sessionId);
+      },
+      unsubscribeConversationEvents: this.options.unsubscribeConversationEvents,
+      removeConversationState: this.options.removeConversationState,
+      activeConversationId: this.options.activeConversationId(),
+      setActiveConversationId: this.options.setActiveConversationId,
+      archiveDirectory: async (targetDirectoryId) => {
+        await this.options.controlPlaneService.archiveDirectory(targetDirectoryId);
+      },
+      deleteDirectory: this.options.deleteDirectory,
+      deleteDirectoryGitState: this.options.deleteDirectoryGitState,
+      projectPaneSnapshotDirectoryId: this.options.projectPaneSnapshotDirectoryId(),
+      clearProjectPaneSnapshot: this.options.clearProjectPaneSnapshot,
+      directoriesSize: this.options.directoriesSize,
+      addDirectoryByPath: async (path) => {
+        await this.addDirectoryByPath(path);
+      },
+      invocationDirectory: this.options.invocationDirectory,
+      activeDirectoryId: this.options.activeDirectoryId(),
+      setActiveDirectoryId: this.options.setActiveDirectoryId,
+      firstDirectoryId: this.options.firstDirectoryId,
+      noteGitActivity: this.options.noteGitActivity,
+      resolveActiveDirectoryId: this.options.resolveActiveDirectoryId,
+      activateConversation: this.options.activateConversation,
+      enterProjectPane: this.options.enterProjectPane,
+      markDirty: this.options.markDirty,
+    });
+  }
+}