markupr 2.1.8

package/src/main/ipc/settingsHandlers.ts

@@ -0,0 +1,471 @@
+/**
+ * Settings IPC Handlers
+ *
+ * Registers IPC handlers for settings read/write, API key management,
+ * permissions, hotkeys, and crash recovery configuration.
+ */
+
+import { ipcMain, dialog, app } from 'electron';
+import * as fs from 'fs/promises';
+import { join } from 'path';
+import { sessionController } from '../SessionController';
+import { hotkeyManager } from '../HotkeyManager';
+import { crashRecovery } from '../CrashRecovery';
+import {
+  IPC_CHANNELS,
+  DEFAULT_SETTINGS,
+  type AppSettings,
+  type HotkeyConfig,
+  type PermissionType,
+  type PermissionStatus,
+  type ApiKeyValidationResult,
+} from '../../shared/types';
+import type { IpcContext, SessionActions } from './types';
+
+// =============================================================================
+// API Key Validation
+// =============================================================================
+
+type ApiKeyProvider = 'openai' | 'anthropic';
+
+async function validateProviderApiKey(
+  service: ApiKeyProvider,
+  key: string,
+): Promise<ApiKeyValidationResult> {
+  const trimmedKey = typeof key === 'string' ? key.trim() : '';
+
+  if (trimmedKey.length < 10) {
+    return {
+      valid: false,
+      error: 'Please enter a valid API key.',
+    };
+  }
+
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), 12000);
+
+  const requestConfig = service === 'openai'
+    ? {
+        url: 'https://api.openai.com/v1/audio/transcriptions',
+        method: 'POST' as const,
+        headers: {
+          Authorization: `Bearer ${trimmedKey}`,
+        } as Record<string, string>,
+        body: new FormData() as BodyInit,
+      }
+    : {
+        url: 'https://api.anthropic.com/v1/models?limit=1',
+        method: 'GET' as const,
+        headers: {
+          'x-api-key': trimmedKey,
+          'anthropic-version': '2023-06-01',
+        } as Record<string, string>,
+        body: undefined as BodyInit | undefined,
+      };
+
+  try {
+    const response = await fetch(requestConfig.url, {
+      method: requestConfig.method,
+      headers: requestConfig.headers,
+      body: requestConfig.body,
+      signal: controller.signal,
+    });
+
+    if (service === 'openai' && response.status === 400) {
+      return { valid: true };
+    }
+
+    if (response.ok) {
+      return { valid: true };
+    }
+
+    if (service === 'openai' && (response.status === 401 || response.status === 403)) {
+      return {
+        valid: false,
+        status: response.status,
+        error:
+          response.status === 401
+            ? 'Invalid OpenAI API key. Please check and try again.'
+            : 'OpenAI key is valid but missing required permissions. Enable model/audio access for this project key and try again.',
+      };
+    }
+
+    if (service === 'anthropic' && (response.status === 401 || response.status === 403)) {
+      return {
+        valid: false,
+        status: response.status,
+        error: 'Invalid Anthropic API key. Please check and try again.',
+      };
+    }
+
+    const providerLabel = service === 'openai' ? 'OpenAI' : 'Anthropic';
+    return {
+      valid: false,
+      status: response.status,
+      error: `${providerLabel} API error (${response.status}). Please try again.`,
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      return {
+        valid: false,
+        error: 'Request timed out. Please check your connection and try again.',
+      };
+    }
+
+    return {
+      valid: false,
+      error: 'Unable to reach API service. Check internet/VPN/firewall and try again.',
+    };
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// =============================================================================
+// IPC Registration
+// =============================================================================
+
+export function registerSettingsHandlers(ctx: IpcContext, actions: SessionActions): void {
+  const { getMainWindow, getSettingsManager, setHasCompletedOnboarding } = ctx;
+
+  // -------------------------------------------------------------------------
+  // Settings Channels
+  // -------------------------------------------------------------------------
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_GET, (_, key: keyof AppSettings) => {
+    return getSettingsManager()?.get(key) ?? DEFAULT_SETTINGS[key];
+  });
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_GET_ALL, (): AppSettings => {
+    return getSettingsManager()?.getAll() ?? { ...DEFAULT_SETTINGS };
+  });
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_SET,
+    (_, key: keyof AppSettings, value: unknown): AppSettings => {
+      const updates = { [key]: value } as Partial<AppSettings>;
+      return getSettingsManager()?.update(updates) ?? { ...DEFAULT_SETTINGS, ...updates };
+    }
+  );
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_SELECT_DIRECTORY, async (): Promise<string | null> => {
+    const mainWindow = getMainWindow();
+    const options: Electron.OpenDialogOptions = {
+      title: 'Select Feedback Output Folder',
+      buttonLabel: 'Use Folder',
+      properties: ['openDirectory', 'createDirectory'],
+    };
+    const result = mainWindow
+      ? await dialog.showOpenDialog(mainWindow, options)
+      : await dialog.showOpenDialog(options);
+
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+
+    const selected = result.filePaths[0];
+    getSettingsManager()?.update({ outputDirectory: selected });
+    return selected;
+  });
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_CLEAR_ALL_DATA, async (): Promise<void> => {
+    const settingsManager = getSettingsManager();
+    if (!settingsManager) {
+      return;
+    }
+
+    const outputDirectory = settingsManager.get('outputDirectory');
+    await fs.rm(outputDirectory, { recursive: true, force: true }).catch(() => {});
+
+    await settingsManager.deleteApiKey('openai').catch(() => {});
+    await settingsManager.deleteApiKey('anthropic').catch(() => {});
+
+    settingsManager.reset();
+    crashRecovery.discardIncompleteSession();
+    crashRecovery.clearCrashLogs();
+    sessionController.reset();
+  });
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_EXPORT, async (): Promise<void> => {
+    const settingsManager = getSettingsManager();
+    if (!settingsManager) {
+      return;
+    }
+
+    const mainWindow = getMainWindow();
+    const options: Electron.SaveDialogOptions = {
+      title: 'Export markupr Settings',
+      defaultPath: join(app.getPath('documents'), 'markupr-settings.json'),
+      filters: [{ name: 'JSON', extensions: ['json'] }],
+    };
+    const result = mainWindow
+      ? await dialog.showSaveDialog(mainWindow, options)
+      : await dialog.showSaveDialog(options);
+
+    if (result.canceled || !result.filePath) {
+      return;
+    }
+
+    const payload = JSON.stringify(settingsManager.getAll(), null, 2);
+    await fs.writeFile(result.filePath, payload, 'utf-8');
+  });
+
+  ipcMain.handle(IPC_CHANNELS.SETTINGS_IMPORT, async (): Promise<AppSettings | null> => {
+    const settingsManager = getSettingsManager();
+    if (!settingsManager) {
+      return null;
+    }
+
+    const mainWindow = getMainWindow();
+    const options: Electron.OpenDialogOptions = {
+      title: 'Import markupr Settings',
+      properties: ['openFile'],
+      filters: [{ name: 'JSON', extensions: ['json'] }],
+    };
+    const result = mainWindow
+      ? await dialog.showOpenDialog(mainWindow, options)
+      : await dialog.showOpenDialog(options);
+
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+
+    const raw = await fs.readFile(result.filePaths[0], 'utf-8');
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('Invalid settings file format.');
+    }
+
+    const entries = Object.entries(parsed as Record<string, unknown>);
+    const allowedKeys = new Set(Object.keys(DEFAULT_SETTINGS));
+    const sanitized: Partial<AppSettings> = {};
+
+    for (const [key, value] of entries) {
+      if (!allowedKeys.has(key)) {
+        continue;
+      }
+      (sanitized as Record<string, unknown>)[key] = value;
+    }
+
+    return settingsManager.update(sanitized);
+  });
+
+  // Legacy settings handlers
+  ipcMain.handle(IPC_CHANNELS.GET_SETTINGS, () => {
+    return getSettingsManager()?.getAll() ?? { ...DEFAULT_SETTINGS };
+  });
+
+  ipcMain.handle(IPC_CHANNELS.SET_SETTINGS, (_, newSettings: Partial<AppSettings>) => {
+    const settings = getSettingsManager()?.update(newSettings) ?? {
+      ...DEFAULT_SETTINGS,
+      ...newSettings,
+    };
+
+    if (newSettings.hotkeys) {
+      const results = hotkeyManager.updateConfig(newSettings.hotkeys);
+      console.log('[Main] Hotkeys updated:', results);
+    }
+
+    if (newSettings.hasCompletedOnboarding) {
+      setHasCompletedOnboarding(true);
+    }
+
+    return settings;
+  });
+
+  // -------------------------------------------------------------------------
+  // API Key Channels (Secure Storage)
+  // -------------------------------------------------------------------------
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_GET_API_KEY,
+    async (_, service: string): Promise<string | null> => {
+      return getSettingsManager()?.getApiKey(service) ?? null;
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_SET_API_KEY,
+    async (_, service: string, key: string): Promise<boolean> => {
+      const settingsManager = getSettingsManager();
+      if (!settingsManager) {
+        return false;
+      }
+
+      try {
+        await settingsManager.setApiKey(service, key);
+
+        for (let attempt = 0; attempt < 3; attempt++) {
+          const persisted = await settingsManager.getApiKey(service);
+          if (persisted && persisted.trim().length > 0) {
+            return true;
+          }
+
+          if (attempt < 2) {
+            await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
+          }
+        }
+
+        if (key.trim().length > 0) {
+          console.warn(
+            `[Main] ${service} API key write verification timed out; accepting write success.`
+          );
+          return true;
+        }
+
+        return false;
+      } catch (error) {
+        console.error(`[Main] Failed to store ${service} API key:`, error);
+        return false;
+      }
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_DELETE_API_KEY,
+    async (_, service: string): Promise<boolean> => {
+      const settingsManager = getSettingsManager();
+      if (!settingsManager) {
+        return false;
+      }
+
+      await settingsManager.deleteApiKey(service);
+      return true;
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_HAS_API_KEY,
+    async (_, service: string): Promise<boolean> => {
+      return getSettingsManager()?.hasApiKey(service) ?? false;
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SETTINGS_TEST_API_KEY,
+    async (_, service: ApiKeyProvider, key: string): Promise<ApiKeyValidationResult> => {
+      if (service !== 'openai' && service !== 'anthropic') {
+        return {
+          valid: false,
+          error: 'Unsupported API provider.',
+        };
+      }
+
+      try {
+        return await validateProviderApiKey(service, key);
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : 'Unknown validation error';
+        console.error(`[Main] API key validation failed for ${service}:`, error);
+        return {
+          valid: false,
+          error: `Unable to validate ${service} API key (${detail}).`,
+        };
+      }
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // Permissions Channels
+  // -------------------------------------------------------------------------
+
+  ipcMain.handle(
+    IPC_CHANNELS.PERMISSIONS_CHECK,
+    async (_, type: PermissionType): Promise<boolean> => {
+      return actions.checkPermission(type);
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.PERMISSIONS_REQUEST,
+    async (_, type: PermissionType): Promise<boolean> => {
+      return actions.requestPermission(type);
+    }
+  );
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSIONS_GET_ALL, async (): Promise<PermissionStatus> => {
+    return {
+      microphone: await actions.checkPermission('microphone'),
+      screen: await actions.checkPermission('screen'),
+      accessibility: await actions.checkPermission('accessibility'),
+    };
+  });
+
+  // -------------------------------------------------------------------------
+  // Hotkey Channels
+  // -------------------------------------------------------------------------
+
+  ipcMain.handle(IPC_CHANNELS.HOTKEY_CONFIG, (): HotkeyConfig => {
+    return hotkeyManager.getConfig();
+  });
+
+  ipcMain.handle(
+    IPC_CHANNELS.HOTKEY_UPDATE,
+    (_, newConfig: Partial<HotkeyConfig>) => {
+      const results = hotkeyManager.updateConfig(newConfig);
+      getSettingsManager()?.update({ hotkeys: hotkeyManager.getConfig() });
+      return { config: hotkeyManager.getConfig(), results };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // Crash Recovery Channels
+  // -------------------------------------------------------------------------
+
+  ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_CHECK, () => {
+    const session = crashRecovery.getIncompleteSession();
+    return {
+      hasIncomplete: !!session,
+      session: session,
+    };
+  });
+
+  ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_RECOVER, (_, sessionId: string) => {
+    const session = crashRecovery.getIncompleteSession();
+    if (!session || session.id !== sessionId) {
+      return {
+        success: false,
+        error: 'Session not found or ID mismatch',
+      };
+    }
+
+    crashRecovery.discardIncompleteSession();
+
+    return {
+      success: true,
+      session: {
+        id: session.id,
+        feedbackItems: session.feedbackItems,
+        startTime: session.startTime,
+        sourceName: session.sourceName,
+        screenshotCount: session.screenshotCount,
+      },
+    };
+  });
+
+  ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_DISCARD, () => {
+    crashRecovery.discardIncompleteSession();
+    return { success: true };
+  });
+
+  ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_GET_LOGS, (_, limit?: number) => {
+    return crashRecovery.getCrashLogs(limit);
+  });
+
+  ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_CLEAR_LOGS, () => {
+    crashRecovery.clearCrashLogs();
+    return { success: true };
+  });
+
+  ipcMain.handle(
+    IPC_CHANNELS.CRASH_RECOVERY_UPDATE_SETTINGS,
+    (_, settings: Partial<{
+      enableAutoSave: boolean;
+      autoSaveIntervalMs: number;
+      enableCrashReporting: boolean;
+      maxCrashLogs: number;
+    }>) => {
+      crashRecovery.updateSettings(settings);
+      return { success: true };
+    }
+  );
+}

package/src/main/ipc/types.ts

@@ -0,0 +1,56 @@
+/**
+ * IPC Handler Dependency Types
+ *
+ * Defines the context interface that IPC handler modules receive
+ * from the main process entry point. Getters are used for mutable state
+ * that changes after initialization.
+ */
+
+import type { BrowserWindow } from 'electron';
+import type { SettingsManager } from '../settings';
+import type { PopoverManager } from '../windows';
+import type { WindowsTaskbar } from '../platform';
+import type { Session } from '../SessionController';
+import type {
+  SessionPayload,
+  PermissionType,
+} from '../../shared/types';
+
+/**
+ * Shared context passed to all IPC handler modules.
+ * Singleton services are imported directly by each module;
+ * only mutable/lazy state needs to flow through here.
+ */
+export interface IpcContext {
+  getMainWindow: () => BrowserWindow | null;
+  getPopover: () => PopoverManager | null;
+  getSettingsManager: () => SettingsManager | null;
+  getWindowsTaskbar: () => WindowsTaskbar | null;
+  getHasCompletedOnboarding: () => boolean;
+  setHasCompletedOnboarding: (value: boolean) => void;
+}
+
+/**
+ * Session-related action functions defined in the main entry point.
+ * These encapsulate complex multi-service orchestration and are
+ * passed to handler modules rather than imported.
+ */
+export interface SessionActions {
+  startSession: (sourceId?: string, sourceName?: string) => Promise<{
+    success: boolean;
+    sessionId?: string;
+    error?: string;
+  }>;
+  stopSession: () => Promise<{
+    success: boolean;
+    session?: SessionPayload;
+    reportPath?: string;
+    error?: string;
+  }>;
+  pauseSession: () => { success: boolean; error?: string };
+  resumeSession: () => { success: boolean; error?: string };
+  cancelSession: () => { success: boolean };
+  serializeSession: (session: Session) => SessionPayload;
+  checkPermission: (type: PermissionType) => Promise<boolean>;
+  requestPermission: (type: PermissionType) => Promise<boolean>;
+}