@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-workspace-observed-events.ts

@@ -1,191 +1,40 @@
-interface WorkspaceObservedReduction {
-  readonly changed: boolean;
-  readonly removedConversationIds: readonly string[];
-  readonly removedDirectoryIds: readonly string[];
-}
-
-interface WorkspaceObservedReducer<TObservedEvent> {
-  apply(observed: TObservedEvent): WorkspaceObservedReduction;
-}
-
-interface RuntimeWorkspaceStateLike {
-  leftNavSelection:
-    | {
-        kind: 'home';
-      }
-    | {
-        kind: 'project';
-        directoryId: string;
-      }
-    | {
-        kind: 'repository';
-        repositoryId: string;
-      }
-    | {
-        kind: 'conversation';
-        sessionId: string;
-      };
-  conversationTitleEdit: {
-    conversationId: string;
-  } | null;
-  projectPaneSnapshot: {
-    directoryId: string;
-  } | null;
-  projectPaneScrollTop: number;
-  activeDirectoryId: string | null;
-  selectLeftNavConversation(sessionId: string): void;
-}
-
-interface RuntimeWorkspaceObservedEventsOptions<TObservedEvent> {
-  readonly reducer: WorkspaceObservedReducer<TObservedEvent>;
-  readonly workspace: RuntimeWorkspaceStateLike;
+import type { HarnessSyncedStore } from '../core/store/harness-synced-store.ts';
+import {
+  enqueueRuntimeWorkspaceObservedReactions,
+  type RuntimeWorkspaceObservedEffectQueueOptions,
+} from './runtime-workspace-observed-effect-queue.ts';
+import {
+  planRuntimeWorkspaceObservedTransition,
+  type RuntimeWorkspaceObservedTransitionPolicyOptions,
+} from './runtime-workspace-observed-transition-policy.ts';
+
+export interface RuntimeWorkspaceObservedEventsOptions {
+  readonly store: HarnessSyncedStore;
   readonly orderedConversationIds: () => readonly string[];
-  readonly conversationDirectoryId: (sessionId: string) => string | null;
-  readonly hasConversation: (sessionId: string) => boolean;
-  readonly getActiveConversationId: () => string | null;
-  readonly setActiveConversationId: (sessionId: string | null) => void;
-  readonly hasDirectory: (directoryId: string) => boolean;
-  readonly resolveActiveDirectoryId: () => string | null;
-  readonly unsubscribeConversationEvents: (sessionId: string) => Promise<void>;
-  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
-  readonly enterProjectPane: (directoryId: string) => void;
-  readonly enterHomePane: () => void;
-  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
-  readonly activateConversation: (sessionId: string) => Promise<void>;
+  readonly transitionPolicy: RuntimeWorkspaceObservedTransitionPolicyOptions;
+  readonly effectQueue: RuntimeWorkspaceObservedEffectQueueOptions;
   readonly markDirty: () => void;
 }
 
-export class RuntimeWorkspaceObservedEvents<TObservedEvent> {
-  constructor(private readonly options: RuntimeWorkspaceObservedEventsOptions<TObservedEvent>) {}
-
-  apply(observed: TObservedEvent): void {
-    const activeConversationIdBefore = this.options.getActiveConversationId();
-    const leftNavConversationIdBefore =
-      this.options.workspace.leftNavSelection.kind === 'conversation'
-        ? this.options.workspace.leftNavSelection.sessionId
-        : null;
-    const previousConversationDirectoryById = new Map<string, string | null>();
-    for (const sessionId of this.options.orderedConversationIds()) {
-      previousConversationDirectoryById.set(
-        sessionId,
-        this.options.conversationDirectoryId(sessionId),
-      );
-    }
-
-    const reduced = this.options.reducer.apply(observed);
-    if (!reduced.changed) {
-      return;
-    }
-
-    for (const sessionId of reduced.removedConversationIds) {
-      void this.options.unsubscribeConversationEvents(sessionId);
-      if (this.options.workspace.conversationTitleEdit?.conversationId === sessionId) {
-        this.options.stopConversationTitleEdit(false);
-      }
-    }
-
-    for (const directoryId of reduced.removedDirectoryIds) {
-      if (this.options.workspace.projectPaneSnapshot?.directoryId === directoryId) {
-        this.options.workspace.projectPaneSnapshot = null;
-        this.options.workspace.projectPaneScrollTop = 0;
-      }
-    }
-
-    if (
-      this.options.workspace.activeDirectoryId !== null &&
-      !this.options.hasDirectory(this.options.workspace.activeDirectoryId)
-    ) {
-      this.options.workspace.activeDirectoryId = this.options.resolveActiveDirectoryId();
-    }
-
-    const removedConversationIdSet = new Set(reduced.removedConversationIds);
-    const activateFallbackConversationInDirectory = (
-      preferredDirectoryId: string | null,
-      label: string,
-    ): boolean => {
-      if (preferredDirectoryId === null) {
-        return false;
-      }
-      const fallbackConversationId =
-        this.options
-          .orderedConversationIds()
-          .find(
-            (sessionId) => this.options.conversationDirectoryId(sessionId) === preferredDirectoryId,
-          ) ?? null;
-      if (fallbackConversationId === null) {
-        return false;
-      }
-      this.options.queueControlPlaneOp(async () => {
-        await this.options.activateConversation(fallbackConversationId);
-      }, label);
-      return true;
-    };
-    const fallbackToDirectoryOrHome = (): void => {
-      const fallbackDirectoryId = this.options.resolveActiveDirectoryId();
-      if (fallbackDirectoryId !== null) {
-        this.options.enterProjectPane(fallbackDirectoryId);
-        return;
-      }
-      this.options.enterHomePane();
-    };
-
-    if (
-      activeConversationIdBefore !== null &&
-      removedConversationIdSet.has(activeConversationIdBefore)
-    ) {
-      this.options.setActiveConversationId(null);
-      const preferredDirectoryId =
-        previousConversationDirectoryById.get(activeConversationIdBefore) ?? null;
-      if (
-        !activateFallbackConversationInDirectory(
-          preferredDirectoryId,
-          'observed-active-conversation-removed',
-        )
-      ) {
-        fallbackToDirectoryOrHome();
-      }
-      this.options.markDirty();
+export function subscribeRuntimeWorkspaceObservedEvents(
+  options: RuntimeWorkspaceObservedEventsOptions,
+): () => void {
+  return options.store.subscribe((state, previousState) => {
+    if (state.synced === previousState.synced) {
       return;
     }
-
-    if (
-      leftNavConversationIdBefore !== null &&
-      removedConversationIdSet.has(leftNavConversationIdBefore)
-    ) {
-      const currentActiveId = this.options.getActiveConversationId();
-      if (currentActiveId !== null && this.options.hasConversation(currentActiveId)) {
-        this.options.workspace.selectLeftNavConversation(currentActiveId);
-        this.options.markDirty();
-        return;
-      }
-      const preferredDirectoryId =
-        previousConversationDirectoryById.get(leftNavConversationIdBefore) ?? null;
-      if (
-        !activateFallbackConversationInDirectory(
-          preferredDirectoryId,
-          'observed-selected-conversation-removed',
-        )
-      ) {
-        fallbackToDirectoryOrHome();
-      }
-      this.options.markDirty();
-      return;
-    }
-
-    if (
-      this.options.workspace.leftNavSelection.kind === 'project' &&
-      !this.options.hasDirectory(this.options.workspace.leftNavSelection.directoryId)
-    ) {
-      const fallbackDirectoryId = this.options.resolveActiveDirectoryId();
-      if (fallbackDirectoryId !== null) {
-        this.options.enterProjectPane(fallbackDirectoryId);
-      } else {
-        this.options.enterHomePane();
-      }
-      this.options.markDirty();
-      return;
-    }
-
-    this.options.markDirty();
-  }
+    const planned = planRuntimeWorkspaceObservedTransition({
+      transition: {
+        previous: previousState.synced,
+        current: state.synced,
+        orderedConversationIds: options.orderedConversationIds(),
+      },
+      options: options.transitionPolicy,
+    });
+    enqueueRuntimeWorkspaceObservedReactions({
+      reactions: planned.reactions,
+      options: options.effectQueue,
+    });
+    options.markDirty();
+  });
 }

package/src/services/runtime-workspace-observed-transition-policy.ts

@@ -0,0 +1,228 @@
+import type { HarnessSyncedState } from '../core/state/synced-observed-state.ts';
+
+interface RuntimeWorkspaceStateLike {
+  leftNavSelection:
+    | {
+        kind: 'home';
+      }
+    | {
+        kind: 'nim';
+      }
+    | {
+        kind: 'tasks';
+      }
+    | {
+        kind: 'project';
+        directoryId: string;
+      }
+    | {
+        kind: 'github';
+        directoryId: string;
+      }
+    | {
+        kind: 'repository';
+        repositoryId: string;
+      }
+    | {
+        kind: 'conversation';
+        sessionId: string;
+      };
+  conversationTitleEdit: {
+    conversationId: string;
+  } | null;
+  projectPaneSnapshot: {
+    directoryId: string;
+  } | null;
+  projectPaneScrollTop: number;
+  activeDirectoryId: string | null;
+  selectLeftNavConversation(sessionId: string): void;
+}
+
+export interface RuntimeWorkspaceObservedTransition {
+  readonly previous: HarnessSyncedState;
+  readonly current: HarnessSyncedState;
+  readonly orderedConversationIds: readonly string[];
+}
+
+export interface RuntimeWorkspaceObservedQueuedReaction {
+  readonly kind: 'unsubscribe-conversation' | 'activate-conversation';
+  readonly sessionId: string;
+  readonly label: string;
+}
+
+export interface RuntimeWorkspaceObservedTransitionPolicyResult {
+  readonly reactions: readonly RuntimeWorkspaceObservedQueuedReaction[];
+}
+
+export interface RuntimeWorkspaceObservedTransitionPolicyOptions {
+  readonly workspace: RuntimeWorkspaceStateLike;
+  readonly getActiveConversationId: () => string | null;
+  readonly setActiveConversationId: (sessionId: string | null) => void;
+  readonly resolveActiveDirectoryId: () => string | null;
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly enterHomePane: () => void;
+}
+
+function conversationDirectoryIdOf(state: HarnessSyncedState, sessionId: string): string | null {
+  return state.conversationsById[sessionId]?.directoryId ?? null;
+}
+
+function hasConversation(state: HarnessSyncedState, sessionId: string): boolean {
+  return state.conversationsById[sessionId] !== undefined;
+}
+
+function hasDirectory(state: HarnessSyncedState, directoryId: string): boolean {
+  return state.directoriesById[directoryId] !== undefined;
+}
+
+function removedIds(
+  previous: Readonly<Record<string, unknown>>,
+  current: Readonly<Record<string, unknown>>,
+): readonly string[] {
+  const removed: string[] = [];
+  for (const id of Object.keys(previous)) {
+    if (current[id] !== undefined) {
+      continue;
+    }
+    removed.push(id);
+  }
+  return removed;
+}
+
+export function planRuntimeWorkspaceObservedTransition(input: {
+  readonly transition: RuntimeWorkspaceObservedTransition;
+  readonly options: RuntimeWorkspaceObservedTransitionPolicyOptions;
+}): RuntimeWorkspaceObservedTransitionPolicyResult {
+  const reactions: RuntimeWorkspaceObservedQueuedReaction[] = [];
+  const removedConversationIds = removedIds(
+    input.transition.previous.conversationsById,
+    input.transition.current.conversationsById,
+  );
+  const removedDirectoryIds = removedIds(
+    input.transition.previous.directoriesById,
+    input.transition.current.directoriesById,
+  );
+  const activeConversationIdBefore = input.options.getActiveConversationId();
+  const leftNavConversationIdBefore =
+    input.options.workspace.leftNavSelection.kind === 'conversation'
+      ? input.options.workspace.leftNavSelection.sessionId
+      : null;
+
+  for (const sessionId of removedConversationIds) {
+    reactions.push({
+      kind: 'unsubscribe-conversation',
+      sessionId,
+      label: `observed-unsubscribe-conversation:${sessionId}`,
+    });
+    if (input.options.workspace.conversationTitleEdit?.conversationId === sessionId) {
+      input.options.stopConversationTitleEdit(false);
+    }
+  }
+
+  for (const directoryId of removedDirectoryIds) {
+    if (input.options.workspace.projectPaneSnapshot?.directoryId === directoryId) {
+      input.options.workspace.projectPaneSnapshot = null;
+      input.options.workspace.projectPaneScrollTop = 0;
+    }
+  }
+
+  if (
+    input.options.workspace.activeDirectoryId !== null &&
+    !hasDirectory(input.transition.current, input.options.workspace.activeDirectoryId)
+  ) {
+    input.options.workspace.activeDirectoryId = input.options.resolveActiveDirectoryId();
+  }
+
+  const removedConversationIdSet = new Set(removedConversationIds);
+  const activateFallbackConversationInDirectory = (
+    preferredDirectoryId: string | null,
+    label: string,
+  ): boolean => {
+    if (preferredDirectoryId === null) {
+      return false;
+    }
+    const fallbackConversationId =
+      input.transition.orderedConversationIds.find(
+        (sessionId) =>
+          conversationDirectoryIdOf(input.transition.current, sessionId) === preferredDirectoryId,
+      ) ?? null;
+    if (fallbackConversationId === null) {
+      return false;
+    }
+    reactions.push({
+      kind: 'activate-conversation',
+      sessionId: fallbackConversationId,
+      label,
+    });
+    return true;
+  };
+
+  const fallbackToDirectoryOrHome = (): void => {
+    const fallbackDirectoryId = input.options.resolveActiveDirectoryId();
+    if (fallbackDirectoryId !== null) {
+      input.options.enterProjectPane(fallbackDirectoryId);
+      return;
+    }
+    input.options.enterHomePane();
+  };
+
+  if (
+    activeConversationIdBefore !== null &&
+    removedConversationIdSet.has(activeConversationIdBefore)
+  ) {
+    input.options.setActiveConversationId(null);
+    const preferredDirectoryId = conversationDirectoryIdOf(
+      input.transition.previous,
+      activeConversationIdBefore,
+    );
+    if (
+      !activateFallbackConversationInDirectory(
+        preferredDirectoryId,
+        'observed-active-conversation-removed',
+      )
+    ) {
+      fallbackToDirectoryOrHome();
+    }
+    return { reactions };
+  }
+
+  if (
+    leftNavConversationIdBefore !== null &&
+    removedConversationIdSet.has(leftNavConversationIdBefore)
+  ) {
+    const currentActiveId = input.options.getActiveConversationId();
+    if (currentActiveId !== null && hasConversation(input.transition.current, currentActiveId)) {
+      input.options.workspace.selectLeftNavConversation(currentActiveId);
+      return { reactions };
+    }
+    const preferredDirectoryId = conversationDirectoryIdOf(
+      input.transition.previous,
+      leftNavConversationIdBefore,
+    );
+    if (
+      !activateFallbackConversationInDirectory(
+        preferredDirectoryId,
+        'observed-selected-conversation-removed',
+      )
+    ) {
+      fallbackToDirectoryOrHome();
+    }
+    return { reactions };
+  }
+
+  if (
+    input.options.workspace.leftNavSelection.kind === 'project' &&
+    !hasDirectory(input.transition.current, input.options.workspace.leftNavSelection.directoryId)
+  ) {
+    const fallbackDirectoryId = input.options.resolveActiveDirectoryId();
+    if (fallbackDirectoryId !== null) {
+      input.options.enterProjectPane(fallbackDirectoryId);
+    } else {
+      input.options.enterHomePane();
+    }
+    return { reactions };
+  }
+
+  return { reactions };
+}

package/src/services/session-diagnostics-store.ts

@@ -0,0 +1,217 @@
+import { closeSync, mkdirSync, openSync, rmSync, writeSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import {
+  renderTraceChunkPreview,
+  type RenderTraceControlIssue,
+} from '../mux/live-mux/render-trace-analysis.ts';
+
+const DEFAULT_MAX_ENTRIES_PER_CONVERSATION = 512;
+export const SESSION_DIAGNOSTICS_FILE_EXTENSION = '.jsonl';
+
+export interface SessionStatusSnapshot {
+  readonly status: string;
+  readonly attentionReason: string | null;
+  readonly live: boolean;
+  readonly phase: string | null;
+  readonly detailText: string | null;
+  readonly lastKnownWork: string | null;
+  readonly lastKnownWorkAt: string | null;
+  readonly telemetrySource: string | null;
+}
+
+export interface UnsupportedControlSequencesEntry {
+  readonly kind: 'unsupported-control-sequences';
+  readonly observedAt: string;
+  readonly source: string;
+  readonly cursor: number;
+  readonly chunkPreview: string;
+  readonly issues: ReadonlyArray<{
+    readonly kind: RenderTraceControlIssue['kind'];
+    readonly offset: number;
+    readonly sequence: string;
+    readonly sequencePreview: string;
+    readonly finalByte?: string;
+    readonly rawParams?: string;
+  }>;
+}
+
+export interface SessionStatusTransitionEntry {
+  readonly kind: 'status-transition';
+  readonly observedAt: string;
+  readonly source: string;
+  readonly from: SessionStatusSnapshot;
+  readonly to: SessionStatusSnapshot;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export type SessionDiagnosticsEntry =
+  | UnsupportedControlSequencesEntry
+  | SessionStatusTransitionEntry;
+
+interface SessionDiagnosticsStoreOptions {
+  readonly maxEntriesPerConversation?: number;
+  readonly diagnosticsDirectory?: string | null;
+}
+
+export class SessionDiagnosticsStore {
+  private readonly maxEntriesPerConversation: number;
+  private readonly diagnosticsDirectory: string | null;
+  private readonly entriesByConversationId = new Map<string, SessionDiagnosticsEntry[]>();
+  private readonly fileDescriptorByConversationId = new Map<string, number>();
+
+  constructor(options: SessionDiagnosticsStoreOptions = {}) {
+    const configuredMax = options.maxEntriesPerConversation;
+    this.maxEntriesPerConversation =
+      typeof configuredMax === 'number' && Number.isFinite(configuredMax)
+        ? Math.max(1, Math.floor(configuredMax))
+        : DEFAULT_MAX_ENTRIES_PER_CONVERSATION;
+    this.diagnosticsDirectory =
+      typeof options.diagnosticsDirectory === 'string' && options.diagnosticsDirectory.length > 0
+        ? resolve(options.diagnosticsDirectory)
+        : null;
+  }
+
+  close(): void {
+    for (const conversationId of this.fileDescriptorByConversationId.keys()) {
+      this.closeConversationFile(conversationId);
+    }
+  }
+
+  recordUnsupportedControlSequences(input: {
+    readonly conversationId: string;
+    readonly observedAt: string;
+    readonly source: string;
+    readonly cursor: number;
+    readonly chunkPreview: string;
+    readonly issues: readonly RenderTraceControlIssue[];
+  }): void {
+    if (input.issues.length === 0) {
+      return;
+    }
+    const normalizedIssues = input.issues.map((issue) => ({
+      kind: issue.kind,
+      offset: issue.offset,
+      sequence: issue.sequence,
+      sequencePreview: renderTraceChunkPreview(issue.sequence, 160),
+      ...(issue.finalByte === undefined ? {} : { finalByte: issue.finalByte }),
+      ...(issue.rawParams === undefined ? {} : { rawParams: issue.rawParams }),
+    }));
+    this.recordConversationEntry(input.conversationId, {
+      kind: 'unsupported-control-sequences',
+      observedAt: input.observedAt,
+      source: input.source,
+      cursor: input.cursor,
+      chunkPreview: input.chunkPreview,
+      issues: normalizedIssues,
+    });
+  }
+
+  recordStatusTransition(input: {
+    readonly conversationId: string;
+    readonly observedAt: string;
+    readonly source: string;
+    readonly from: SessionStatusSnapshot;
+    readonly to: SessionStatusSnapshot;
+    readonly metadata?: Record<string, unknown>;
+  }): void {
+    this.recordConversationEntry(input.conversationId, {
+      kind: 'status-transition',
+      observedAt: input.observedAt,
+      source: input.source,
+      from: input.from,
+      to: input.to,
+      ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+    });
+  }
+
+  listConversationEntries(conversationId: string): readonly SessionDiagnosticsEntry[] {
+    const entries = this.entriesByConversationId.get(conversationId);
+    return entries === undefined ? [] : [...entries];
+  }
+
+  clearConversation(conversationId: string): void {
+    this.entriesByConversationId.delete(conversationId);
+    this.closeConversationFile(conversationId);
+    const filePath = this.resolveConversationDiagnosticsPath(conversationId);
+    if (filePath === null) {
+      return;
+    }
+    try {
+      rmSync(filePath, { force: true });
+    } catch {
+      // Best-effort cleanup only.
+    }
+  }
+
+  private recordConversationEntry(conversationId: string, entry: SessionDiagnosticsEntry): void {
+    const entries = this.entriesByConversationId.get(conversationId) ?? [];
+    entries.push(entry);
+    if (entries.length > this.maxEntriesPerConversation) {
+      entries.splice(0, entries.length - this.maxEntriesPerConversation);
+    }
+    this.entriesByConversationId.set(conversationId, entries);
+    this.writeConversationEntry(conversationId, entry);
+  }
+
+  private writeConversationEntry(conversationId: string, entry: SessionDiagnosticsEntry): void {
+    const filePath = this.resolveConversationDiagnosticsPath(conversationId);
+    if (filePath === null) {
+      return;
+    }
+    const fd = this.ensureConversationFile(conversationId, filePath);
+    if (fd === null) {
+      return;
+    }
+    const record = {
+      conversationId,
+      ...entry,
+    };
+    try {
+      writeSync(fd, `${JSON.stringify(record)}\n`);
+    } catch {
+      this.closeConversationFile(conversationId);
+    }
+  }
+
+  private ensureConversationFile(conversationId: string, filePath: string): number | null {
+    const existing = this.fileDescriptorByConversationId.get(conversationId);
+    if (existing !== undefined) {
+      return existing;
+    }
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+      const fd = openSync(filePath, 'a');
+      this.fileDescriptorByConversationId.set(conversationId, fd);
+      return fd;
+    } catch {
+      this.closeConversationFile(conversationId);
+      return null;
+    }
+  }
+
+  private closeConversationFile(conversationId: string): void {
+    const fd = this.fileDescriptorByConversationId.get(conversationId);
+    if (fd === undefined) {
+      return;
+    }
+    try {
+      closeSync(fd);
+    } catch {
+      // Best-effort close only.
+    }
+    this.fileDescriptorByConversationId.delete(conversationId);
+  }
+
+  private resolveConversationDiagnosticsPath(conversationId: string): string | null {
+    if (this.diagnosticsDirectory === null) {
+      return null;
+    }
+    const fileToken = sanitizeFileToken(conversationId);
+    return resolve(this.diagnosticsDirectory, `${fileToken}${SESSION_DIAGNOSTICS_FILE_EXTENSION}`);
+  }
+}
+
+function sanitizeFileToken(value: string): string {
+  const normalized = value.trim().replace(/[^A-Za-z0-9._-]+/gu, '-');
+  return normalized.length === 0 ? 'conversation' : normalized;
+}