store configs

Author: jasonzh0

src/main/ipc/dialogs.ts

@@ -3,7 +3,9 @@
  */
 
 import { ipcMain, dialog, BrowserWindow } from 'electron';
-import { setConfiguredOutputPath, getConfiguredOutputPath } from '../state';
+import { setConfiguredOutputDir, getConfiguredOutputDir } from '../state';
+import { loadConfig, saveConfig } from '../state';
+import type { UserConfig } from '../state';
 
 /**
  * Register dialog-related IPC handlers
@@ -14,31 +16,29 @@ export function registerDialogHandlers(
 ): void {
   ipcMain.handle('select-output-path', async () => {
     const mainWindow = getMainWindow();
-    const result = await dialog.showSaveDialog(mainWindow!, {
-      title: 'Save Recording',
-      defaultPath: `recording_${Date.now()}.mp4`,
-      filters: [
-        { name: 'Video Files', extensions: ['mp4', 'mov'] },
-        { name: 'All Files', extensions: ['*'] },
-      ],
+    const currentDir = getConfiguredOutputDir();
+    const result = await dialog.showOpenDialog(mainWindow!, {
+      title: 'Select Save Location',
+      defaultPath: currentDir || undefined,
+      properties: ['openDirectory', 'createDirectory'],
     });
 
-    if (result.canceled) {
+    if (result.canceled || !result.filePaths || result.filePaths.length === 0) {
       return null;
     }
 
-    // Store the configured output path
-    setConfiguredOutputPath(result.filePath || null);
-    return result.filePath;
+    const dir = result.filePaths[0];
+    setConfiguredOutputDir(dir);
+    return dir;
   });
 
-  ipcMain.handle('set-output-path', async (_, path: string | null) => {
-    setConfiguredOutputPath(path);
+  ipcMain.handle('set-output-path', async (_, dir: string | null) => {
+    setConfiguredOutputDir(dir);
     return { success: true };
   });
 
   ipcMain.handle('get-output-path', async () => {
-    return getConfiguredOutputPath();
+    return getConfiguredOutputDir();
   });
 
   ipcMain.handle('select-video-file', async () => {
@@ -76,4 +76,15 @@ export function registerDialogHandlers(
 
     return result.filePaths[0];
   });
+
+  ipcMain.handle('get-user-config', async () => {
+    return loadConfig();
+  });
+
+  ipcMain.handle('set-user-config', async (_, partial: Partial<UserConfig>) => {
+    const config = loadConfig();
+    Object.assign(config, partial);
+    saveConfig(config);
+    return { success: true };
+  });
 }

src/main/ipc/recording-bar.ts

@@ -9,7 +9,6 @@ import type { Platform } from '../../platform';
 import type { CursorConfig, ZoomConfig } from '../../types';
 import { MetadataExporter } from '../../processing/metadata-exporter';
 import { createLogger } from '../../utils/logger';
-import { DEFAULT_FRAME_RATE, DEFAULT_CURSOR_SIZE } from '../../utils/constants';
 import {
   getRecordingState,
   getCurrentRecordingConfig,
@@ -21,6 +20,7 @@ import {
   createScreenCapture,
   createMouseTracker,
   cleanupRecording,
+  loadConfig,
 } from '../state';
 import {
   showRecordingBar,
@@ -55,15 +55,17 @@ export function registerRecordingBarHandlers(
     // Stop the timer immediately so UI shows recording has ended
     stopRecordingBarTimer();
 
-    // Use default configs for stop
+    // Load configs from persistent store
+    const userConfig = loadConfig();
+
     const cursorConfig: CursorConfig = {
-      size: DEFAULT_CURSOR_SIZE,
-      shape: 'arrow',
+      size: userConfig.cursorSize,
+      shape: userConfig.cursorShape as CursorConfig['shape'],
     };
 
     const zoomConfig: ZoomConfig = {
-      enabled: true,
-      level: 2.0,
+      enabled: userConfig.zoomEnabled,
+      level: userConfig.zoomLevel,
       transitionSpeed: 300,
       padding: 0,
       followSpeed: 1.0,
@@ -150,7 +152,7 @@ export function registerRecordingBarHandlers(
         mouseEvents: adjustedMouseEvents,
         cursorConfig,
         zoomConfig,
-        frameRate: DEFAULT_FRAME_RATE,
+        frameRate: parseInt(userConfig.frameRate, 10) || 60,
         videoDuration: recordingDuration,
         screenDimensions,
         recordingRegion: currentRecordingConfig?.region,
@@ -352,10 +354,11 @@ export function registerRecordingBarHandlers(
       outputPath: configuredOutputPath,
     });
 
-    // Create a default recording config
+    // Create recording config from persisted settings
+    const userConfig = loadConfig();
     setCurrentRecordingConfig({
       outputPath: configuredOutputPath,
-      frameRate: DEFAULT_FRAME_RATE,
+      frameRate: parseInt(userConfig.frameRate, 10) || 60,
     });
 
     const mainWindow = getMainWindow();

src/main/ipc/recording.ts

@@ -9,7 +9,6 @@ import type { Platform } from '../../platform';
 import type { RecordingConfig, CursorConfig, ZoomConfig, MouseEffectsConfig } from '../../types';
 import { MetadataExporter } from '../../processing/metadata-exporter';
 import { createLogger } from '../../utils/logger';
-import { DEFAULT_FRAME_RATE, DEFAULT_CURSOR_SIZE } from '../../utils/constants';
 import {
   getRecordingState,
   getCurrentRecordingConfig,
@@ -19,6 +18,7 @@ import {
   getMouseTracker,
   createScreenCapture,
   createMouseTracker,
+  loadConfig,
 } from '../state';
 import { showRecordingBar, hideRecordingBar, stopRecordingBarTimer } from '../recording-bar-window';
 
@@ -149,9 +149,10 @@ export function registerRecordingHandlers(
     mouseEffectsConfig?: MouseEffectsConfig;
   } | CursorConfig) => {
     // Handle both old format (just CursorConfig) and new format (object with cursorConfig)
+    const userConfig = loadConfig();
     let cursorConfig: CursorConfig = {
-      size: DEFAULT_CURSOR_SIZE,
-      shape: 'arrow',
+      size: userConfig.cursorSize,
+      shape: userConfig.cursorShape as CursorConfig['shape'],
     };
     let zoomConfig: ZoomConfig | undefined;
     let mouseEffectsConfig: MouseEffectsConfig | undefined;
@@ -278,7 +279,7 @@ export function registerRecordingHandlers(
         cursorConfig,
         zoomConfig,
         mouseEffectsConfig,
-        frameRate: DEFAULT_FRAME_RATE,
+        frameRate: parseInt(userConfig.frameRate, 10) || 60,
         videoDuration: recordingDuration,
         screenDimensions,
         recordingRegion: currentRecordingConfig?.region,

src/main/ipc/studio.ts

@@ -9,7 +9,7 @@ import { VideoProcessor } from '../../processing/video-processor';
 import { MetadataExporter } from '../../processing/metadata-exporter';
 import type { RecordingMetadata } from '../../types/metadata';
 import { createLogger } from '../../utils/logger';
-import { DEFAULT_FRAME_RATE } from '../../utils/constants';
+import { loadConfig } from '../state';
 
 const logger = createLogger('IPC:Studio');
 
@@ -60,7 +60,7 @@ export function registerStudioHandlers(
     return {
       width: dimensions.width,
       height: dimensions.height,
-      frameRate: DEFAULT_FRAME_RATE, // Default, could be extracted from video
+      frameRate: parseInt(loadConfig().frameRate, 10) || 60,
       duration: 0, // Would need to extract from video metadata
     };
   });

src/main/screen-capture.ts

@@ -5,7 +5,7 @@ import type { RecordingConfig } from '../types';
 import { getFfmpegPath } from '../utils/ffmpeg-path';
 import { waitForFileStable, validateVideoFile } from '../utils/file-utils';
 import { createLogger } from '../utils/logger';
-import { DEFAULT_FRAME_RATE } from '../utils/constants';
+import { loadConfig } from './state';
 
 // Create logger for screen capture
 const logger = createLogger('ScreenCapture');
@@ -110,7 +110,7 @@ export class ScreenCapture {
    * Uses platform-specific input methods
    */
   private async buildRecordingArgs(config: RecordingConfig): Promise<string[]> {
-    const frameRate = String(config.frameRate || DEFAULT_FRAME_RATE);
+    const frameRate = String(config.frameRate || parseInt(loadConfig().frameRate, 10) || 60);
 
     if (isWindows) {
       // Windows: use gdigrab for desktop capture

src/main/state/config-store.ts

@@ -0,0 +1,79 @@
+/**
+ * Persistent user config storage
+ * Reads/writes config.json in the platform-appropriate userData directory
+ */
+
+import { app } from 'electron';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('ConfigStore');
+
+export interface UserConfig {
+  // Recording
+  outputDir: string | null;
+  frameRate: string;
+
+  // Cursor
+  cursorSize: number;
+  cursorShape: string;
+
+  // Zoom
+  zoomEnabled: boolean;
+  zoomLevel: number;
+  zoomAnimation: string;
+
+  // Click effects
+  clickCirclesEnabled: boolean;
+  clickCircleColor: string;
+}
+
+const defaults: UserConfig = {
+  outputDir: null,
+  frameRate: '60',
+
+  cursorSize: 32,
+  cursorShape: 'arrow',
+
+  zoomEnabled: true,
+  zoomLevel: 2.0,
+  zoomAnimation: 'mellow',
+
+  clickCirclesEnabled: false,
+  clickCircleColor: '#ffffff',
+};
+
+function configPath(): string {
+  return join(app.getPath('userData'), 'config.json');
+}
+
+export function loadConfig(): UserConfig {
+  try {
+    const raw = readFileSync(configPath(), 'utf-8');
+    const parsed = JSON.parse(raw);
+    return { ...defaults, ...parsed };
+  } catch {
+    return { ...defaults };
+  }
+}
+
+export function saveConfig(config: UserConfig): void {
+  try {
+    const dir = app.getPath('userData');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(configPath(), JSON.stringify(config, null, 2), 'utf-8');
+  } catch (error) {
+    logger.error('Failed to save config:', error);
+  }
+}
+
+export function getConfigValue<K extends keyof UserConfig>(key: K): UserConfig[K] {
+  return loadConfig()[key];
+}
+
+export function setConfigValue<K extends keyof UserConfig>(key: K, value: UserConfig[K]): void {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}

src/main/state/index.ts

@@ -4,13 +4,22 @@
 export {
   getRecordingState,
   getCurrentRecordingConfig,
+  getConfiguredOutputDir,
   getConfiguredOutputPath,
   getScreenCapture,
   getMouseTracker,
   setRecordingState,
   setCurrentRecordingConfig,
-  setConfiguredOutputPath,
+  setConfiguredOutputDir,
   createScreenCapture,
   createMouseTracker,
   cleanupRecording,
 } from './recording-state';
+
+export {
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue,
+} from './config-store';
+export type { UserConfig } from './config-store';

src/main/state/recording-state.ts

@@ -4,12 +4,14 @@
  */
 
 import { existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
 import { ScreenCapture } from '../screen-capture';
 import { MouseTracker } from '../mouse-tracker';
 import type { RecordingConfig, RecordingState } from '../../types';
 import type { Platform } from '../../platform';
 import { createLogger } from '../../utils/logger';
 import { showRecordingBarIdle } from '../recording-bar-window';
+import { getConfigValue, setConfigValue } from './config-store';
 
 const logger = createLogger('RecordingState');
 
@@ -18,7 +20,7 @@ let recordingState: RecordingState = {
   isRecording: false,
 };
 let currentRecordingConfig: RecordingConfig | null = null;
-let configuredOutputPath: string | null = null;
+let configuredOutputDir: string | null | undefined = undefined;
 
 // Components
 let screenCapture: ScreenCapture | null = null;
@@ -33,8 +35,16 @@ export function getCurrentRecordingConfig(): RecordingConfig | null {
   return currentRecordingConfig;
 }
 
+export function getConfiguredOutputDir(): string | null {
+  if (configuredOutputDir === undefined) {
+    configuredOutputDir = getConfigValue('outputDir');
+  }
+  return configuredOutputDir;
+}
+
 export function getConfiguredOutputPath(): string | null {
-  return configuredOutputPath;
+  const dir = getConfiguredOutputDir();
+  return dir ? join(dir, `recording_${Date.now()}.mp4`) : null;
 }
 
 export function getScreenCapture(): ScreenCapture | null {
@@ -54,8 +64,9 @@ export function setCurrentRecordingConfig(config: RecordingConfig | null): void
   currentRecordingConfig = config;
 }
 
-export function setConfiguredOutputPath(path: string | null): void {
-  configuredOutputPath = path;
+export function setConfiguredOutputDir(dir: string | null): void {
+  configuredOutputDir = dir;
+  setConfigValue('outputDir', dir);
 }
 
 // Create new instances