markupr 2.1.8

package/src/main/ipc/captureHandlers.ts

@@ -0,0 +1,272 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+/**
+ * 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

@@ -0,0 +1,302 @@
+/**
+ * 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

@@ -0,0 +1,56 @@
+/**
+ * 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();
+  });
+}