markupr 2.1.8

package/src/renderer/contexts/RecordingContext.tsx

@@ -0,0 +1,683 @@
+/**
+ * RecordingContext
+ *
+ * Manages the core recording session lifecycle: state machine, IPC listeners,
+ * screen recording sync, audio levels, output paths, and session actions.
+ * This is the foundational context that other contexts depend on.
+ */
+
+import React, { createContext, useCallback, useContext, useEffect, useRef, useState } from 'react';
+import type { SessionPayload, SessionState, ReviewSession } from '../../shared/types';
+import { getScreenRecordingRenderer } from '../capture/ScreenRecordingRenderer';
+import { useCrashRecovery } from '../components';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ProcessingProgress {
+  percent: number;
+  step: string;
+}
+
+export interface RecentSession {
+  id: string;
+  startTime: number;
+  endTime: number;
+  itemCount: number;
+  screenshotCount: number;
+  sourceName: string;
+  firstThumbnail?: string;
+  folder: string;
+  transcriptionPreview?: string;
+}
+
+export interface LastCapture {
+  trigger?: 'pause' | 'manual' | 'voice-command';
+  timestamp: number;
+}
+
+export interface RecordingContextValue {
+  // Session state
+  state: SessionState;
+  duration: number;
+  screenshotCount: number;
+  isPaused: boolean;
+  isMutating: boolean;
+
+  // Audio
+  audioLevel: number;
+  isVoiceActive: boolean;
+  lastCapture: LastCapture | null;
+
+  // Output
+  reportPath: string | null;
+  recordingPath: string | null;
+  audioPath: string | null;
+  sessionDir: string | null;
+  reviewSession: ReviewSession | null;
+  errorMessage: string | null;
+
+  // Capability
+  hasTranscriptionCapability: boolean | null;
+
+  // Recent sessions
+  recentSessions: RecentSession[];
+  loadRecentSessions: () => Promise<void>;
+
+  // Processing raw state (consumed by ProcessingContext)
+  rawProcessingProgress: ProcessingProgress | null;
+  processingStartedAt: number | null;
+
+  // Review editor
+  showReviewEditor: boolean;
+  setShowReviewEditor: (show: boolean) => void;
+
+  // Crash recovery
+  incompleteSession: ReturnType<typeof useCrashRecovery>['incompleteSession'];
+  isCheckingRecovery: boolean;
+
+  // Actions
+  startSession: () => Promise<void>;
+  stopSession: () => Promise<void>;
+  togglePause: () => Promise<void>;
+  manualCapture: () => Promise<void>;
+  copyReportPath: () => Promise<void>;
+  openReportFolder: () => Promise<void>;
+  copyRecordingPath: () => Promise<void>;
+  copyAudioPath: () => Promise<void>;
+  openRecent: (session: { folder: string }) => Promise<void>;
+  copyRecentPath: (session: { folder: string }) => Promise<void>;
+  recoverSession: () => void;
+  discardSession: () => void;
+  reviewSave: (session: ReviewSession) => Promise<void>;
+  reviewClose: () => void;
+}
+
+const RecordingContext = createContext<RecordingContextValue | null>(null);
+
+export function useRecording(): RecordingContextValue {
+  const context = useContext(RecordingContext);
+  if (!context) {
+    throw new Error('useRecording must be used within RecordingProvider');
+  }
+  return context;
+}
+
+// ============================================================================
+// Provider
+// ============================================================================
+
+export const RecordingProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  // ---------------------------------------------------------------------------
+  // Session state
+  // ---------------------------------------------------------------------------
+  const [state, setState] = useState<SessionState>('idle');
+  const [duration, setDuration] = useState(0);
+  const [screenshotCount, setScreenshotCount] = useState(0);
+  const [isPaused, setIsPaused] = useState(false);
+  const [isMutating, setIsMutating] = useState(false);
+  const [audioLevel, setAudioLevel] = useState(0);
+  const [isVoiceActive, setIsVoiceActive] = useState(false);
+  const [lastCapture, setLastCapture] = useState<LastCapture | null>(null);
+  const [reportPath, setReportPath] = useState<string | null>(null);
+  const [recordingPath, setRecordingPath] = useState<string | null>(null);
+  const [audioPath, setAudioPath] = useState<string | null>(null);
+  const [sessionDir, setSessionDir] = useState<string | null>(null);
+  const [reviewSession, setReviewSession] = useState<ReviewSession | null>(null);
+  const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const [hasTranscriptionCapability, setHasTranscriptionCapability] = useState<boolean | null>(null);
+  const [recentSessions, setRecentSessions] = useState<RecentSession[]>([]);
+  const [rawProcessingProgress, setRawProcessingProgress] = useState<ProcessingProgress | null>(null);
+  const [showReviewEditor, setShowReviewEditor] = useState(false);
+
+  // Refs
+  const outputReadyRef = useRef(false);
+  const processingStartedAtRef = useRef<number | null>(null);
+  const stopRequestedRef = useRef(false);
+  const screenRecorderRef = useRef(getScreenRecordingRenderer());
+  const screenSyncQueueRef = useRef<Promise<void>>(Promise.resolve());
+
+  // ---------------------------------------------------------------------------
+  // Crash recovery
+  // ---------------------------------------------------------------------------
+  const {
+    incompleteSession,
+    isCheckingRecovery,
+    recoverSession: rawRecoverSession,
+    discardSession: rawDiscardSession,
+  } = useCrashRecovery();
+
+  // ---------------------------------------------------------------------------
+  // Recent sessions
+  // ---------------------------------------------------------------------------
+  const loadRecentSessions = useCallback(async () => {
+    try {
+      if (!window.markupr?.output?.listSessions) {
+        setRecentSessions([]);
+        return;
+      }
+      const sessions = await window.markupr.output.listSessions();
+      setRecentSessions(sessions.slice(0, 5));
+    } catch (error) {
+      console.error('[RecordingContext] Failed to load recent sessions:', error);
+      setRecentSessions([]);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadRecentSessions();
+  }, [loadRecentSessions]);
+
+  // ---------------------------------------------------------------------------
+  // Transcription capability check
+  // ---------------------------------------------------------------------------
+  useEffect(() => {
+    window.markupr.whisper
+      .hasTranscriptionCapability()
+      .then((ready) => setHasTranscriptionCapability(ready))
+      .catch(() => setHasTranscriptionCapability(false));
+  }, []);
+
+  // ---------------------------------------------------------------------------
+  // Screen recording sync
+  // ---------------------------------------------------------------------------
+  const syncScreenRecording = useCallback(
+    async (nextState: SessionState, session: SessionPayload | null, paused: boolean) => {
+      const recorder = screenRecorderRef.current;
+
+      if (nextState === 'recording') {
+        if (stopRequestedRef.current) {
+          recorder.releaseCaptureTracks();
+          if (recorder.isRecording() || recorder.getSessionId()) {
+            await recorder.stop().catch((error) => {
+              console.warn('[RecordingContext] Forced recorder stop during stop-request guard failed:', error);
+            });
+          }
+          return;
+        }
+
+        const latestStatus = await window.markupr.session.getStatus().catch(() => null);
+        if (latestStatus && latestStatus.state !== 'recording') {
+          if (recorder.isRecording() || recorder.getSessionId()) {
+            await recorder.stop().catch((error) => {
+              console.warn('[RecordingContext] Forced recorder stop during stale recording status guard failed:', error);
+            });
+          }
+          return;
+        }
+
+        if (!recorder.isRecording()) {
+          let activeSession = session;
+          if (!activeSession) {
+            for (let attempt = 0; attempt < 4; attempt += 1) {
+              activeSession = await window.markupr.session.getCurrent();
+              if (activeSession) break;
+              if (attempt < 3) {
+                await new Promise((resolve) => setTimeout(resolve, 180));
+              }
+            }
+          }
+
+          if (!activeSession) {
+            setErrorMessage((prev) => prev || 'Session started, but screen recorder could not find an active capture target.');
+            return;
+          }
+
+          try {
+            await recorder.start({
+              sessionId: activeSession.id,
+              sourceId: activeSession.sourceId,
+            });
+          } catch (error) {
+            console.warn('[RecordingContext] Continuous screen recording failed to start with primary source:', error);
+
+            try {
+              const sources = await window.markupr.capture.getSources();
+              const fallbackSource = sources.find((source) => source.type === 'screen');
+
+              if (!fallbackSource || fallbackSource.id === activeSession.sourceId) {
+                throw error;
+              }
+
+              await recorder.start({
+                sessionId: activeSession.id,
+                sourceId: fallbackSource.id,
+              });
+            } catch (fallbackError) {
+              const message =
+                fallbackError instanceof Error
+                  ? fallbackError.message
+                  : 'Unknown screen recording error.';
+              console.warn('[RecordingContext] Continuous screen recording fallback also failed:', message);
+              setErrorMessage((prev) => prev || `Screen recording unavailable: ${message}`);
+              return;
+            }
+          }
+        }
+
+        if (paused) {
+          await recorder.pause();
+        } else {
+          await recorder.resume();
+        }
+        return;
+      }
+
+      recorder.releaseCaptureTracks();
+      if (recorder.isRecording() || recorder.getSessionId()) {
+        await recorder.stop().catch((error) => {
+          console.warn('[RecordingContext] Failed to stop continuous screen recording:', error);
+        });
+      }
+      recorder.forceReleaseOrphanedCapture();
+    },
+    []
+  );
+
+  const queueScreenRecordingSync = useCallback(
+    (nextState: SessionState, session: SessionPayload | null, paused: boolean) => {
+      screenSyncQueueRef.current = screenSyncQueueRef.current
+        .catch(() => {})
+        .then(() => syncScreenRecording(nextState, session, paused));
+      return screenSyncQueueRef.current;
+    },
+    [syncScreenRecording]
+  );
+
+  // ---------------------------------------------------------------------------
+  // Session IPC listeners
+  // ---------------------------------------------------------------------------
+  useEffect(() => {
+    let mounted = true;
+    const recorder = screenRecorderRef.current;
+
+    window.markupr.session
+      .getStatus()
+      .then((status) => {
+        if (!mounted) return;
+        setState(status.state);
+        setDuration(status.duration);
+        setScreenshotCount(status.screenshotCount);
+        setIsPaused(status.isPaused);
+        void queueScreenRecordingSync(status.state, null, status.isPaused);
+      })
+      .catch((error) => {
+        console.error('[RecordingContext] Failed to load initial status:', error);
+      });
+
+    const toUiState = (nextState: SessionState): SessionState =>
+      nextState === 'complete' && !outputReadyRef.current ? 'processing' : nextState;
+
+    const unsubState = window.markupr.session.onStateChange(({ state: nextState, session }) => {
+      const effectiveState =
+        stopRequestedRef.current && nextState === 'recording' ? 'stopping' : nextState;
+      setState(toUiState(effectiveState));
+      void queueScreenRecordingSync(effectiveState, session, false);
+      if (nextState === 'recording') {
+        stopRequestedRef.current = false;
+        outputReadyRef.current = false;
+        setErrorMessage(null);
+        setReportPath(null);
+        setRecordingPath(null);
+        setAudioPath(null);
+        setSessionDir(null);
+        setReviewSession(null);
+        setShowReviewEditor(false);
+        setRawProcessingProgress(null);
+        processingStartedAtRef.current = null;
+        setIsPaused(false);
+      }
+      if (nextState === 'stopping' || nextState === 'processing') {
+        stopRequestedRef.current = true;
+        if (!processingStartedAtRef.current) {
+          processingStartedAtRef.current = Date.now();
+        }
+        setRawProcessingProgress((previous) => previous ?? { percent: 0, step: 'preparing' });
+      }
+      if (nextState === 'idle') {
+        stopRequestedRef.current = false;
+        outputReadyRef.current = false;
+        setDuration(0);
+        setRawProcessingProgress(null);
+        processingStartedAtRef.current = null;
+        setIsPaused(false);
+      }
+    });
+
+    const unsubStatus = window.markupr.session.onStatusUpdate((status) => {
+      if (status.state === 'stopping' || status.state === 'processing') {
+        stopRequestedRef.current = true;
+      }
+      const effectiveState =
+        stopRequestedRef.current && status.state === 'recording' ? 'stopping' : status.state;
+      setDuration(status.duration);
+      setScreenshotCount(status.screenshotCount);
+      setState(toUiState(effectiveState));
+      setIsPaused(status.isPaused);
+      void queueScreenRecordingSync(effectiveState, null, status.isPaused);
+    });
+
+    const unsubScreenshot = window.markupr.capture.onScreenshot((payload) => {
+      setScreenshotCount(payload.count);
+      setLastCapture({
+        trigger: payload.trigger,
+        timestamp: payload.timestamp,
+      });
+    });
+
+    const unsubReady = window.markupr.output.onReady((payload) => {
+      recorder.releaseCaptureTracks();
+      recorder.forceReleaseOrphanedCapture();
+      void queueScreenRecordingSync('idle', null, false).catch((error) => {
+        console.warn('[RecordingContext] Failed to force-release screen recorder on output ready:', error);
+      });
+      window.setTimeout(() => {
+        recorder.forceReleaseOrphanedCapture();
+        void queueScreenRecordingSync('idle', null, false).catch(() => {});
+      }, 450);
+      stopRequestedRef.current = false;
+      outputReadyRef.current = true;
+      setRawProcessingProgress({ percent: 100, step: 'complete' });
+      setState('complete');
+      setErrorMessage(null);
+      setReportPath(payload.path || payload.reportPath || null);
+      setRecordingPath(payload.recordingPath || null);
+      setAudioPath(payload.audioPath || null);
+      setSessionDir(payload.sessionDir || null);
+      setReviewSession(payload.reviewSession || null);
+      setShowReviewEditor(false);
+      setDuration(0);
+      loadRecentSessions();
+      processingStartedAtRef.current = null;
+    });
+
+    const unsubSessionError = window.markupr.session.onError((payload) => {
+      stopRequestedRef.current = false;
+      outputReadyRef.current = false;
+      setState('error');
+      setErrorMessage(payload.message);
+    });
+
+    const unsubOutputError = window.markupr.output.onError((payload) => {
+      stopRequestedRef.current = false;
+      outputReadyRef.current = false;
+      setState('error');
+      setErrorMessage(payload.message);
+    });
+
+    return () => {
+      mounted = false;
+      unsubState();
+      unsubStatus();
+      unsubScreenshot();
+      unsubReady();
+      unsubSessionError();
+      unsubOutputError();
+
+      if (recorder.isRecording()) {
+        void recorder.stop();
+      }
+    };
+  }, [loadRecentSessions, queueScreenRecordingSync]);
+
+  // ---------------------------------------------------------------------------
+  // Audio level + voice activity listeners
+  // ---------------------------------------------------------------------------
+  useEffect(() => {
+    const unsubLevel = window.markupr.audio.onLevel((level) => {
+      setAudioLevel(level);
+    });
+    const unsubVoice = window.markupr.audio.onVoiceActivity((active) => {
+      setIsVoiceActive(active);
+    });
+    const unsubSessionVoice = window.markupr.session.onVoiceActivity(({ active }) => {
+      setIsVoiceActive(active);
+    });
+
+    return () => {
+      unsubLevel();
+      unsubVoice();
+      unsubSessionVoice();
+    };
+  }, []);
+
+  // ---------------------------------------------------------------------------
+  // Post-processing progress listeners
+  // ---------------------------------------------------------------------------
+  useEffect(() => {
+    const markuprApi = window.markupr as Record<string, unknown>;
+    let unsubProgress: (() => void) | null = null;
+    let unsubComplete: (() => void) | null = null;
+
+    if (markuprApi.processing && typeof (markuprApi.processing as Record<string, unknown>).onProgress === 'function') {
+      const processingApi = markuprApi.processing as {
+        onProgress: (cb: (data: ProcessingProgress) => void) => () => void;
+        onComplete: (cb: (data: unknown) => void) => () => void;
+      };
+      unsubProgress = processingApi.onProgress((data) => {
+        setRawProcessingProgress({
+          percent: Math.max(0, Math.min(100, Math.round(data.percent))),
+          step: data.step,
+        });
+      });
+      unsubComplete = processingApi.onComplete(() => {
+        setRawProcessingProgress({ percent: 100, step: 'complete' });
+      });
+    }
+
+    return () => {
+      unsubProgress?.();
+      unsubComplete?.();
+    };
+  }, []);
+
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  const startSession = useCallback(async () => {
+    setIsMutating(true);
+    try {
+      setScreenshotCount(0);
+      setLastCapture(null);
+      setRecordingPath(null);
+      setAudioPath(null);
+      setErrorMessage(null);
+      stopRequestedRef.current = false;
+      outputReadyRef.current = false;
+
+      const result = await window.markupr.session.start();
+      if (!result.success) {
+        setState('error');
+        setErrorMessage(result.error || 'Unable to start session.');
+        window.markupr.whisper
+          .hasTranscriptionCapability()
+          .then((ready) => setHasTranscriptionCapability(ready))
+          .catch(() => {});
+      } else {
+        const activeSession = await window.markupr.session.getCurrent();
+        if (activeSession) {
+          await queueScreenRecordingSync('recording', activeSession, false);
+        }
+      }
+    } catch (error) {
+      setState('error');
+      setErrorMessage(error instanceof Error ? error.message : 'Unknown session error.');
+    } finally {
+      setIsMutating(false);
+    }
+  }, [queueScreenRecordingSync]);
+
+  const stopSession = useCallback(async () => {
+    setIsMutating(true);
+    try {
+      stopRequestedRef.current = true;
+
+      const recorder = screenRecorderRef.current;
+      recorder.releaseCaptureTracks();
+
+      try {
+        await queueScreenRecordingSync('idle', null, false);
+      } catch (error) {
+        console.warn('[RecordingContext] Failed to flush screen recording before stop:', error);
+      }
+
+      const result = await window.markupr.session.stop();
+      if (!result.success) {
+        setState('error');
+        setErrorMessage(result.error || 'Unable to stop session.');
+      }
+    } catch (error) {
+      setState('error');
+      setErrorMessage(error instanceof Error ? error.message : 'Unknown session error.');
+    } finally {
+      setIsMutating(false);
+    }
+  }, [queueScreenRecordingSync]);
+
+  const togglePause = useCallback(async () => {
+    if (state !== 'recording') return;
+
+    setIsMutating(true);
+    try {
+      if (isPaused) {
+        const result = await window.markupr.session.resume();
+        if (!result.success) {
+          setErrorMessage(result.error || 'Unable to resume session.');
+          return;
+        }
+        setIsPaused(false);
+        await queueScreenRecordingSync('recording', null, false);
+        return;
+      }
+
+      const result = await window.markupr.session.pause();
+      if (!result.success) {
+        setErrorMessage(result.error || 'Unable to pause session.');
+        return;
+      }
+      setIsPaused(true);
+      setIsVoiceActive(false);
+      await queueScreenRecordingSync('recording', null, true);
+    } catch (error) {
+      setErrorMessage(error instanceof Error ? error.message : 'Pause/resume failed.');
+    } finally {
+      setIsMutating(false);
+    }
+  }, [isPaused, state, queueScreenRecordingSync]);
+
+  const manualCapture = useCallback(async () => {
+    if (state !== 'recording' || isPaused || isMutating) return;
+    const result = await window.markupr.capture.manualScreenshot();
+    if (!result.success) {
+      setErrorMessage(result.error || 'Manual capture failed.');
+    }
+  }, [state, isPaused, isMutating]);
+
+  const copyReportPath = useCallback(async () => {
+    if (!reportPath) return;
+    await window.markupr.copyToClipboard(reportPath);
+  }, [reportPath]);
+
+  const openReportFolder = useCallback(async () => {
+    if (sessionDir) {
+      await window.markupr.output.openFolder(sessionDir);
+      return;
+    }
+    if (reportPath) {
+      await window.markupr.output.openFolder(reportPath);
+    }
+  }, [sessionDir, reportPath]);
+
+  const copyRecordingPath = useCallback(async () => {
+    if (!recordingPath) return;
+    await window.markupr.copyToClipboard(recordingPath);
+  }, [recordingPath]);
+
+  const copyAudioPath = useCallback(async () => {
+    if (!audioPath) return;
+    await window.markupr.copyToClipboard(audioPath);
+  }, [audioPath]);
+
+  const openRecent = useCallback(async (session: { folder: string }) => {
+    await window.markupr.output.openFolder(session.folder);
+  }, []);
+
+  const copyRecentPath = useCallback(async (session: { folder: string }) => {
+    await window.markupr.copyToClipboard(`${session.folder}/feedback-report.md`);
+  }, []);
+
+  const recoverSession = useCallback(() => {
+    rawRecoverSession();
+    outputReadyRef.current = true;
+    setState('complete');
+    loadRecentSessions();
+  }, [rawRecoverSession, loadRecentSessions]);
+
+  const discardSession = useCallback(() => {
+    rawDiscardSession();
+  }, [rawDiscardSession]);
+
+  const reviewSave = useCallback(async (_session: ReviewSession) => {
+    try {
+      await window.markupr.output.save();
+    } catch {
+      // Save failure is non-fatal in review mode
+    }
+  }, []);
+
+  const reviewClose = useCallback(() => {
+    setShowReviewEditor(false);
+  }, []);
+
+  // ---------------------------------------------------------------------------
+  // Context value
+  // ---------------------------------------------------------------------------
+  const value: RecordingContextValue = {
+    state,
+    duration,
+    screenshotCount,
+    isPaused,
+    isMutating,
+    audioLevel,
+    isVoiceActive,
+    lastCapture,
+    reportPath,
+    recordingPath,
+    audioPath,
+    sessionDir,
+    reviewSession,
+    errorMessage,
+    hasTranscriptionCapability,
+    recentSessions,
+    loadRecentSessions,
+    rawProcessingProgress,
+    processingStartedAt: processingStartedAtRef.current,
+    showReviewEditor,
+    setShowReviewEditor,
+    incompleteSession,
+    isCheckingRecovery,
+    startSession,
+    stopSession,
+    togglePause,
+    manualCapture,
+    copyReportPath,
+    openReportFolder,
+    copyRecordingPath,
+    copyAudioPath,
+    openRecent,
+    copyRecentPath,
+    recoverSession,
+    discardSession,
+    reviewSave,
+    reviewClose,
+  };
+
+  return (
+    <RecordingContext.Provider value={value}>
+      {children}
+    </RecordingContext.Provider>
+  );
+};
+
+export default RecordingContext;