markupr 2.1.8 → 2.5.0

package/src/main/ipc/captureHandlers.ts

@@ -1,272 +0,0 @@
-/**
- * Capture IPC Handlers
- *
- * Registers IPC handlers for screen capture source enumeration,
- * persisted screen recording (start/chunk/stop), and audio device management.
- */
-
-import { ipcMain, desktopCapturer, app } from 'electron';
-import * as fs from 'fs/promises';
-import { join } from 'path';
-import { sessionController } from '../SessionController';
-import {
-  IPC_CHANNELS,
-  DEFAULT_SETTINGS,
-  type CaptureSource,
-  type AudioDevice,
-} from '../../shared/types';
-import type { IpcContext } from './types';
-
-// =============================================================================
-// Screen Recording State
-// =============================================================================
-
-interface RecordingArtifact {
-  tempPath: string;
-  mimeType: string;
-  bytesWritten: number;
-  writeChain: Promise<void>;
-  lastChunkAt: number;
-  startTime?: number;
-}
-
-interface FinalizedRecordingArtifact {
-  tempPath: string;
-  mimeType: string;
-  bytesWritten: number;
-  startTime?: number;
-}
-
-const activeScreenRecordings = new Map<string, RecordingArtifact>();
-const finalizedScreenRecordings = new Map<string, FinalizedRecordingArtifact>();
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function extensionFromMimeType(mimeType?: string): string {
-  const normalized = (mimeType || '').toLowerCase();
-  if (normalized.includes('mp4')) {
-    return '.mp4';
-  }
-  if (normalized.includes('quicktime') || normalized.includes('mov')) {
-    return '.mov';
-  }
-  return '.webm';
-}
-
-export async function finalizeScreenRecording(sessionId: string): Promise<FinalizedRecordingArtifact | null> {
-  const active = activeScreenRecordings.get(sessionId);
-  if (active) {
-    const QUIET_PERIOD_MS = 750;
-    const MAX_WAIT_MS = 6000;
-    const waitStartedAt = Date.now();
-
-    while (Date.now() - waitStartedAt < MAX_WAIT_MS) {
-      try {
-        await active.writeChain;
-      } catch (error) {
-        console.warn('[Main] Screen recording write chain failed during finalize:', error);
-      }
-
-      const idleMs = Date.now() - active.lastChunkAt;
-      if (idleMs >= QUIET_PERIOD_MS) {
-        break;
-      }
-
-      await sleep(Math.min(180, QUIET_PERIOD_MS - idleMs));
-    }
-
-    try {
-      await active.writeChain;
-    } catch (error) {
-      console.warn('[Main] Screen recording write chain failed during finalize:', error);
-    }
-
-    activeScreenRecordings.delete(sessionId);
-    finalizedScreenRecordings.set(sessionId, {
-      tempPath: active.tempPath,
-      mimeType: active.mimeType,
-      bytesWritten: active.bytesWritten,
-      startTime: active.startTime,
-    });
-  }
-
-  return finalizedScreenRecordings.get(sessionId) || null;
-}
-
-export function getScreenRecordingSnapshot(sessionId: string): FinalizedRecordingArtifact | null {
-  const active = activeScreenRecordings.get(sessionId);
-  if (active) {
-    return {
-      tempPath: active.tempPath,
-      mimeType: active.mimeType,
-      bytesWritten: active.bytesWritten,
-      startTime: active.startTime,
-    };
-  }
-
-  return finalizedScreenRecordings.get(sessionId) || null;
-}
-
-export function deleteFinalizedRecording(sessionId: string): void {
-  finalizedScreenRecordings.delete(sessionId);
-}
-
-export function getActiveScreenRecordings(): Map<string, RecordingArtifact> {
-  return activeScreenRecordings;
-}
-
-export function getFinalizedScreenRecordings(): Map<string, FinalizedRecordingArtifact> {
-  return finalizedScreenRecordings;
-}
-
-// =============================================================================
-// IPC Registration
-// =============================================================================
-
-export function registerCaptureHandlers(ctx: IpcContext): void {
-  ipcMain.handle(IPC_CHANNELS.CAPTURE_GET_SOURCES, async (): Promise<CaptureSource[]> => {
-    try {
-      const sources = await desktopCapturer.getSources({
-        types: ['screen', 'window'],
-        thumbnailSize: { width: 320, height: 180 },
-        fetchWindowIcons: true,
-      });
-
-      return sources.map((source) => ({
-        id: source.id,
-        name: source.name,
-        type: source.id.startsWith('screen') ? 'screen' : 'window',
-        thumbnail: source.thumbnail.toDataURL(),
-        appIcon: source.appIcon?.toDataURL(),
-      }));
-    } catch (error) {
-      console.error('[Main] Failed to get capture sources:', error);
-      return [];
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.CAPTURE_MANUAL_SCREENSHOT, async () => {
-    const cue = sessionController.registerCaptureCue('manual');
-    if (!cue) {
-      return { success: false, error: 'Manual capture is only available while recording and not paused.' };
-    }
-    return { success: true };
-  });
-
-  ipcMain.handle(
-    IPC_CHANNELS.SCREEN_RECORDING_START,
-    async (_, sessionId: string, mimeType: string, startTime?: number): Promise<{ success: boolean; path?: string; error?: string }> => {
-      try {
-        const currentSession = sessionController.getSession();
-        if (!currentSession || currentSession.id !== sessionId) {
-          return { success: false, error: 'No matching active session for screen recording.' };
-        }
-
-        const extension = extensionFromMimeType(mimeType);
-        const recordingsDir = join(app.getPath('temp'), 'markupr-recordings');
-        await fs.mkdir(recordingsDir, { recursive: true });
-
-        const tempPath = join(recordingsDir, `${sessionId}${extension}`);
-        await fs.writeFile(tempPath, Buffer.alloc(0));
-
-        activeScreenRecordings.set(sessionId, {
-          tempPath,
-          mimeType: mimeType || 'video/webm',
-          bytesWritten: 0,
-          writeChain: Promise.resolve(),
-          lastChunkAt: Date.now(),
-          startTime,
-        });
-
-        return { success: true, path: tempPath };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : 'Failed to initialize screen recording.',
-        };
-      }
-    }
-  );
-
-  ipcMain.handle(
-    IPC_CHANNELS.SCREEN_RECORDING_CHUNK,
-    async (
-      _,
-      sessionId: string,
-      chunk: Uint8Array | ArrayBuffer
-    ): Promise<{ success: boolean; error?: string }> => {
-      const recording = activeScreenRecordings.get(sessionId);
-      if (!recording) {
-        return { success: false, error: 'No active recording writer for this session.' };
-      }
-
-      let buffer: Buffer;
-      if (chunk instanceof ArrayBuffer) {
-        buffer = Buffer.from(chunk);
-      } else if (ArrayBuffer.isView(chunk)) {
-        buffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-      } else {
-        return { success: false, error: 'Unsupported recording chunk format.' };
-      }
-
-      recording.writeChain = recording.writeChain
-        .then(() => fs.appendFile(recording.tempPath, buffer))
-        .then(() => {
-          recording.bytesWritten += buffer.byteLength;
-          recording.lastChunkAt = Date.now();
-        });
-
-      try {
-        await recording.writeChain;
-        return { success: true };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : 'Failed to append recording chunk.',
-        };
-      }
-    }
-  );
-
-  ipcMain.handle(
-    IPC_CHANNELS.SCREEN_RECORDING_STOP,
-    async (
-      _,
-      sessionId: string
-    ): Promise<{ success: boolean; path?: string; bytes?: number; mimeType?: string; error?: string }> => {
-      try {
-        const artifact = await finalizeScreenRecording(sessionId);
-        if (!artifact) {
-          return { success: true };
-        }
-
-        return {
-          success: true,
-          path: artifact.tempPath,
-          bytes: artifact.bytesWritten,
-          mimeType: artifact.mimeType,
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : 'Failed to finalize screen recording.',
-        };
-      }
-    }
-  );
-
-  // Audio device handlers
-  ipcMain.handle(IPC_CHANNELS.AUDIO_GET_DEVICES, async (): Promise<AudioDevice[]> => {
-    return [];
-  });
-
-  ipcMain.handle(IPC_CHANNELS.AUDIO_SET_DEVICE, async (_, deviceId: string) => {
-    const settingsManager = ctx.getSettingsManager();
-    const settings = settingsManager?.getAll() || DEFAULT_SETTINGS;
-    settingsManager?.update({ ...settings, preferredAudioDevice: deviceId });
-    ctx.getMainWindow()?.webContents.send(IPC_CHANNELS.AUDIO_SET_DEVICE, deviceId);
-    return { success: true };
-  });
-}

package/src/main/ipc/index.ts

@@ -1,45 +0,0 @@
-/**
- * IPC Handler Barrel
- *
- * Aggregates all domain-specific IPC handler modules and
- * provides a single registration entry point for the main process.
- */
-
-export { registerSessionHandlers } from './sessionHandlers';
-export { registerCaptureHandlers } from './captureHandlers';
-export { registerSettingsHandlers } from './settingsHandlers';
-export { registerOutputHandlers } from './outputHandlers';
-export { registerWindowHandlers } from './windowHandlers';
-export type { IpcContext, SessionActions } from './types';
-
-// Re-export capture utilities used by the main entry point
-export {
-  extensionFromMimeType,
-  finalizeScreenRecording,
-  getScreenRecordingSnapshot,
-  deleteFinalizedRecording,
-  getActiveScreenRecordings,
-  getFinalizedScreenRecordings,
-} from './captureHandlers';
-
-// Re-export session history used by the main entry point
-export { listSessionHistoryItems } from './outputHandlers';
-
-import type { IpcContext, SessionActions } from './types';
-import { registerSessionHandlers } from './sessionHandlers';
-import { registerCaptureHandlers } from './captureHandlers';
-import { registerSettingsHandlers } from './settingsHandlers';
-import { registerOutputHandlers } from './outputHandlers';
-import { registerWindowHandlers } from './windowHandlers';
-
-/**
- * Register all IPC handlers in a single call.
- * Called from the main entry point after all services are initialized.
- */
-export function registerAllHandlers(ctx: IpcContext, actions: SessionActions): void {
-  registerSessionHandlers(ctx, actions);
-  registerCaptureHandlers(ctx);
-  registerSettingsHandlers(ctx, actions);
-  registerOutputHandlers(ctx);
-  registerWindowHandlers(ctx);
-}

package/src/main/ipc/outputHandlers.ts

@@ -1,302 +0,0 @@
-/**
- * Output IPC Handlers
- *
- * Registers IPC handlers for session output operations:
- * save, clipboard, session history, export, and deletion.
- */
-
-import { ipcMain, shell } from 'electron';
-import * as fs from 'fs/promises';
-import { join, basename } from 'path';
-import { sessionController } from '../SessionController';
-import {
-  fileManager,
-  outputManager,
-  clipboardService,
-  generateDocumentForFileManager,
-} from '../output';
-import { processSession as aiProcessSession } from '../ai';
-import { IPC_CHANNELS, type SaveResult } from '../../shared/types';
-import type { IpcContext } from './types';
-
-// =============================================================================
-// Session History Types and Helpers
-// =============================================================================
-
-interface ListedSessionMetadata {
-  sessionId: string;
-  startTime: number;
-  endTime?: number;
-  itemCount: number;
-  screenshotCount: number;
-  source?: {
-    id: string;
-    name?: string;
-  };
-}
-
-interface SessionHistoryItem {
-  id: string;
-  startTime: number;
-  endTime: number;
-  itemCount: number;
-  screenshotCount: number;
-  sourceName: string;
-  firstThumbnail?: string;
-  folder: string;
-  transcriptionPreview?: string;
-}
-
-function extractPreviewFromMarkdown(content: string): string | undefined {
-  const blockMatch = content.match(/#### Feedback\s*\n> ([\s\S]*?)(?:\n\n|\n---|$)/);
-  const fallbackLine = content.split('\n').find((line) => line.startsWith('> '));
-  const rawPreview = blockMatch?.[1] || fallbackLine?.replace(/^>\s*/, '');
-
-  if (!rawPreview) {
-    return undefined;
-  }
-
-  const singleLine = rawPreview.replace(/\n>\s*/g, ' ').replace(/\s+/g, ' ').trim();
-  return singleLine.slice(0, 220);
-}
-
-async function resolveSessionThumbnail(sessionDir: string): Promise<string | undefined> {
-  const screenshotsDir = join(sessionDir, 'screenshots');
-
-  try {
-    const files = await fs.readdir(screenshotsDir);
-    const firstImage = files
-      .filter((file) => /\.(png|jpe?g|webp)$/i.test(file))
-      .sort()[0];
-
-    if (!firstImage) {
-      return undefined;
-    }
-
-    return join(screenshotsDir, firstImage);
-  } catch {
-    return undefined;
-  }
-}
-
-async function buildSessionHistoryItem(
-  dir: string,
-  metadata: ListedSessionMetadata
-): Promise<SessionHistoryItem> {
-  const markdownPath = join(dir, 'feedback-report.md');
-
-  let transcriptionPreview: string | undefined;
-  try {
-    const markdown = await fs.readFile(markdownPath, 'utf-8');
-    transcriptionPreview = extractPreviewFromMarkdown(markdown);
-  } catch {
-    transcriptionPreview = undefined;
-  }
-
-  return {
-    id: metadata.sessionId,
-    startTime: metadata.startTime,
-    endTime: metadata.endTime || metadata.startTime,
-    itemCount: metadata.itemCount || 0,
-    screenshotCount: metadata.screenshotCount || 0,
-    sourceName: metadata.source?.name || 'Feedback Session',
-    firstThumbnail: await resolveSessionThumbnail(dir),
-    folder: dir,
-    transcriptionPreview,
-  };
-}
-
-export async function listSessionHistoryItems(): Promise<SessionHistoryItem[]> {
-  const sessions = await fileManager.listSessions();
-  const items = await Promise.all(
-    sessions.map(({ dir, metadata }) =>
-      buildSessionHistoryItem(dir, metadata as ListedSessionMetadata)
-    )
-  );
-  return items.sort((a, b) => b.startTime - a.startTime);
-}
-
-async function getSessionHistoryItem(sessionId: string): Promise<SessionHistoryItem | null> {
-  const sessions = await listSessionHistoryItems();
-  return sessions.find((session) => session.id === sessionId) || null;
-}
-
-async function exportSessionFolders(sessionIds: string[]): Promise<string> {
-  const sessions = await listSessionHistoryItems();
-  const selected = sessions.filter((session) => sessionIds.includes(session.id));
-
-  if (!selected.length) {
-    throw new Error('No sessions found to export.');
-  }
-
-  const exportRoot = join(fileManager.getOutputDirectory(), 'exports');
-  const bundleDir = join(exportRoot, `bundle-${Date.now()}`);
-  await fs.mkdir(bundleDir, { recursive: true });
-
-  for (const session of selected) {
-    const destination = join(bundleDir, basename(session.folder));
-    await fs.cp(session.folder, destination, { recursive: true });
-  }
-
-  return bundleDir;
-}
-
-// =============================================================================
-// IPC Registration
-// =============================================================================
-
-export function registerOutputHandlers(ctx: IpcContext): void {
-  const { getSettingsManager } = ctx;
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_SAVE, async (): Promise<SaveResult> => {
-    try {
-      const session = sessionController.getSession();
-      if (!session) {
-        return { success: false, error: 'No session to save' };
-      }
-
-      const settingsManager = getSettingsManager();
-      const { document } = settingsManager
-        ? await aiProcessSession(session, {
-            settingsManager,
-            projectName: session.metadata?.sourceName || 'Feedback Session',
-            screenshotDir: './screenshots',
-          })
-        : {
-            document: generateDocumentForFileManager(session, {
-              projectName: session.metadata?.sourceName || 'Feedback Session',
-              screenshotDir: './screenshots',
-            }),
-          };
-
-      const result = await fileManager.saveSession(session, document);
-      return {
-        success: result.success,
-        path: result.sessionDir,
-        error: result.error,
-      };
-    } catch (error) {
-      console.error('[Main] Failed to save session:', error);
-      return { success: false, error: (error as Error).message };
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_COPY_CLIPBOARD, async (): Promise<boolean> => {
-    try {
-      const session = sessionController.getSession();
-      if (!session) {
-        console.warn('[Main] No session to copy');
-        return false;
-      }
-
-      return await outputManager.copySessionSummary(session);
-    } catch (error) {
-      console.error('[Main] Failed to copy to clipboard:', error);
-      return false;
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_OPEN_FOLDER, async (_, sessionDir?: string) => {
-    try {
-      const dir = sessionDir || fileManager.getOutputDirectory();
-      await shell.openPath(dir);
-      return { success: true };
-    } catch (error) {
-      console.error('[Main] Failed to open folder:', error);
-      return { success: false, error: (error as Error).message };
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_LIST_SESSIONS, async () => {
-    try {
-      return await listSessionHistoryItems();
-    } catch (error) {
-      console.error('[Main] Failed to list sessions:', error);
-      return [];
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_GET_SESSION_METADATA, async (_, sessionId: string) => {
-    try {
-      return await getSessionHistoryItem(sessionId);
-    } catch (error) {
-      console.error('[Main] Failed to get session metadata:', error);
-      return null;
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_DELETE_SESSION, async (_, sessionId: string) => {
-    try {
-      const session = await getSessionHistoryItem(sessionId);
-      if (!session) {
-        return { success: false, error: 'Session not found' };
-      }
-
-      await fs.rm(session.folder, { recursive: true, force: true });
-      return { success: true };
-    } catch (error) {
-      console.error('[Main] Failed to delete session:', error);
-      return { success: false, error: (error as Error).message };
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OUTPUT_DELETE_SESSIONS, async (_, sessionIds: string[]) => {
-    const deleted: string[] = [];
-    const failed: string[] = [];
-
-    for (const sessionId of sessionIds) {
-      try {
-        const session = await getSessionHistoryItem(sessionId);
-        if (!session) {
-          failed.push(sessionId);
-          continue;
-        }
-
-        await fs.rm(session.folder, { recursive: true, force: true });
-        deleted.push(sessionId);
-      } catch {
-        failed.push(sessionId);
-      }
-    }
-
-    return {
-      success: failed.length === 0,
-      deleted,
-      failed,
-    };
-  });
-
-  ipcMain.handle(
-    IPC_CHANNELS.OUTPUT_EXPORT_SESSION,
-    async (_, sessionId: string, format: 'markdown' | 'json' | 'pdf' = 'markdown') => {
-      try {
-        console.log(`[Main] Exporting session ${sessionId} as ${format}`);
-        const exportPath = await exportSessionFolders([sessionId]);
-        return { success: true, path: exportPath };
-      } catch (error) {
-        console.error('[Main] Failed to export session:', error);
-        return { success: false, error: (error as Error).message };
-      }
-    }
-  );
-
-  ipcMain.handle(
-    IPC_CHANNELS.OUTPUT_EXPORT_SESSIONS,
-    async (_, sessionIds: string[], format: 'markdown' | 'json' | 'pdf' = 'markdown') => {
-      try {
-        console.log(`[Main] Exporting ${sessionIds.length} sessions as ${format}`);
-        const exportPath = await exportSessionFolders(sessionIds);
-        return { success: true, path: exportPath };
-      } catch (error) {
-        console.error('[Main] Failed to export sessions:', error);
-        return { success: false, error: (error as Error).message };
-      }
-    }
-  );
-
-  // Legacy clipboard handler
-  ipcMain.handle(IPC_CHANNELS.COPY_TO_CLIPBOARD, async (_, text: string) => {
-    const success = await clipboardService.copyWithNotification(text);
-    return { success };
-  });
-}

package/src/main/ipc/sessionHandlers.ts

@@ -1,56 +0,0 @@
-/**
- * Session IPC Handlers
- *
- * Registers IPC handlers for session lifecycle operations:
- * start, stop, pause, resume, cancel, status queries.
- */
-
-import { ipcMain } from 'electron';
-import { sessionController } from '../SessionController';
-import { IPC_CHANNELS, type SessionStatusPayload, type SessionPayload } from '../../shared/types';
-import type { IpcContext, SessionActions } from './types';
-
-export function registerSessionHandlers(ctx: IpcContext, actions: SessionActions): void {
-  ipcMain.handle(IPC_CHANNELS.SESSION_START, async (_, sourceId?: string, sourceName?: string) => {
-    console.log('[Main] Starting session');
-    return actions.startSession(sourceId, sourceName);
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_STOP, async () => {
-    console.log('[Main] Stopping session');
-    return actions.stopSession();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_PAUSE, async () => {
-    console.log('[Main] Pausing session');
-    return actions.pauseSession();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_RESUME, async () => {
-    console.log('[Main] Resuming session');
-    return actions.resumeSession();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_CANCEL, async () => {
-    console.log('[Main] Cancelling session');
-    return actions.cancelSession();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_GET_STATUS, (): SessionStatusPayload => {
-    return sessionController.getStatus();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.SESSION_GET_CURRENT, (): SessionPayload | null => {
-    const session = sessionController.getSession();
-    return session ? actions.serializeSession(session) : null;
-  });
-
-  // Legacy session handlers (for backwards compatibility)
-  ipcMain.handle(IPC_CHANNELS.START_SESSION, async (_, sourceId?: string) => {
-    return actions.startSession(sourceId);
-  });
-
-  ipcMain.handle(IPC_CHANNELS.STOP_SESSION, async () => {
-    return actions.stopSession();
-  });
-}