added config file (#21)

Author: matthieuEv

.env.e2e

@@ -0,0 +1 @@
+VITE_E2E=1

.github/workflows/ci.yml

@@ -32,11 +32,11 @@ jobs:
       - name: Run tests
         run: npm run test
 
+      - name: Build
+        run: npm run build
+
       - name: Install Playwright browsers
         run: npx playwright install --with-deps chromium
 
       - name: Run e2e tests
         run: npm run test:e2e
-
-      - name: Build
-        run: npm run build

electron/main.js

@@ -30,6 +30,7 @@ const MAIA_DOWNLOAD_BASE_URL = normalizeBaseUrl(
 const VIBECHESS_DIR_NAME = '.vibeChess';
 const ENGINE_DIR_NAME = 'engine';
 const MAIA_DIR_NAME = 'maia';
+const CONFIG_FILE_NAME = 'config.json';
 const STOCKFISH_JS = 'stockfish-17.1-lite-single-03e3232.js';
 const STOCKFISH_WASM = 'stockfish-17.1-lite-single-03e3232.wasm';
 const ZEROFISH_JS = 'zerofishEngine.js';
@@ -122,6 +123,7 @@ const ENGINE_ASSETS = LEGACY_ENGINE_DOWNLOAD_BASE_URL
     ];
 
 const getVibeChessDir = () => path.join(app.getPath('home'), VIBECHESS_DIR_NAME);
+const getConfigPath = () => path.join(getVibeChessDir(), CONFIG_FILE_NAME);
 
 const buildEnginePaths = (baseDir, serverPort) => {
   if (serverPort) {
@@ -156,6 +158,26 @@ const fileExists = async (filePath) => {
   }
 };
 
+const readConfigFile = async () => {
+  const configPath = getConfigPath();
+  try {
+    const raw = await fs.promises.readFile(configPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+const writeConfigFile = async (payload) => {
+  const configPath = getConfigPath();
+  await fs.promises.mkdir(getVibeChessDir(), { recursive: true });
+  const tempPath = `${configPath}.tmp`;
+  const json = JSON.stringify(payload ?? {}, null, 2);
+  await fs.promises.writeFile(tempPath, json, 'utf8');
+  await fs.promises.rename(tempPath, configPath);
+  return true;
+};
+
 const toNodeStream = (body) => {
   if (!body) return null;
   if (typeof body.pipe === 'function') return body;
@@ -208,6 +230,14 @@ const sendDownloadEvent = (webContentsSet, payload) => {
 
 let activeDownload = null;
 
+ipcMain.handle('config:read', async () => {
+  return readConfigFile();
+});
+
+ipcMain.handle('config:write', async (_event, payload) => {
+  return writeConfigFile(payload);
+});
+
 const ensureEngineAssets = async (webContentsSet, serverPort) => {
   const baseDir = getVibeChessDir();
   await fs.promises.mkdir(baseDir, { recursive: true });

playwright.config.ts

@@ -12,12 +12,10 @@ export default defineConfig({
     screenshot: 'only-on-failure',
   },
   webServer: {
-    command: 'npx vite preview --host 127.0.0.1 --port 4173',
+    command:
+      'npx vite build --mode e2e && npx vite preview --host 127.0.0.1 --port 4173 --strictPort',
     url: 'http://127.0.0.1:4173',
     reuseExistingServer: !process.env.CI,
-    env: {
-      VITE_E2E: '1',
-    },
   },
   projects: [
     {

src/App.tsx

@@ -26,6 +26,7 @@ import {
   type EngineAssets,
   type EngineDownloadEvent,
 } from './engine/engineAssets'
+import { loadPlayerConfig, savePlayerConfig, type PlayerConfig } from './playerConfig'
 import Settings, { BOARD_THEMES, type BoardThemeKey } from './Settings'
 
 type Suggestion = {
@@ -175,6 +176,7 @@ function App() {
   const [takebackLimit, setTakebackLimit] = useState<number>(Infinity)
   const [takebacksUsed, setTakebacksUsed] = useState(0)
   const [allowEloChangeMidGame, setAllowEloChangeMidGame] = useState(false)
+  const [configReady, setConfigReady] = useState(false)
 
   // Click-to-move helper state
   const [selectedSquare, setSelectedSquare] = useState<Square | null>(null)
@@ -200,6 +202,45 @@ function App() {
     }
   }, [ensureEngineAssets])
 
+  useEffect(() => {
+    let cancelled = false
+
+    const loadConfig = async () => {
+      try {
+        const config = await loadPlayerConfig()
+        if (cancelled || !config) return
+        if (config.gameMode) setGameMode(config.gameMode)
+        if (config.colorChoice) setColorChoice(config.colorChoice)
+        if (config.elo !== undefined) setElo(config.elo)
+        if (config.boardTheme) setBoardThemeKey(config.boardTheme)
+        if (config.takebackLimit !== undefined) setTakebackLimit(config.takebackLimit)
+        if (config.allowEloChangeMidGame !== undefined) {
+          setAllowEloChangeMidGame(config.allowEloChangeMidGame)
+        }
+      } finally {
+        if (!cancelled) setConfigReady(true)
+      }
+    }
+
+    void loadConfig()
+    return () => {
+      cancelled = true
+    }
+  }, [setAllowEloChangeMidGame, setBoardThemeKey, setColorChoice, setElo, setGameMode, setTakebackLimit])
+
+  useEffect(() => {
+    if (!configReady) return
+    const payload: PlayerConfig = {
+      gameMode,
+      colorChoice,
+      elo,
+      boardTheme: boardThemeKey,
+      takebackLimit,
+      allowEloChangeMidGame,
+    }
+    void savePlayerConfig(payload)
+  }, [allowEloChangeMidGame, boardThemeKey, colorChoice, configReady, elo, gameMode, takebackLimit])
+
   const sendEngine = useCallback((cmd: string) => {
     const worker = analysisWorkerRef.current
     if (!worker) return

src/playerConfig.ts

@@ -0,0 +1,109 @@
+import type { BoardThemeKey } from './Settings'
+import type { ColorChoice, GameMode } from './chess/types'
+import { snapMaiaElo, type MaiaElo } from './engine/maiaEngine'
+
+export type PlayerConfig = {
+  gameMode: GameMode
+  colorChoice: ColorChoice
+  elo: MaiaElo
+  boardTheme: BoardThemeKey
+  takebackLimit: number
+  allowEloChangeMidGame: boolean
+}
+
+type StoredPlayerConfig = Omit<PlayerConfig, 'takebackLimit'> & {
+  takebackLimit: number | null
+}
+
+const LOCAL_STORAGE_KEY = 'vibeChess.config'
+
+const getIpcRenderer = () => {
+  if (typeof window === 'undefined') return null
+  const anyWindow = window as typeof window & { require?: (module: string) => unknown }
+  if (!anyWindow?.process?.versions?.electron || !anyWindow.require) return null
+  try {
+    return anyWindow.require('electron').ipcRenderer as {
+      invoke: (channel: string, ...args: unknown[]) => Promise<unknown>
+    }
+  } catch {
+    return null
+  }
+}
+
+const isGameMode = (value: unknown): value is GameMode =>
+  value === 'vs-maia' || value === '1v1'
+
+const isColorChoice = (value: unknown): value is ColorChoice =>
+  value === 'white' || value === 'black' || value === 'random'
+
+const isBoardThemeKey = (value: unknown): value is BoardThemeKey =>
+  value === 'green' || value === 'brown' || value === 'blue' || value === 'gray'
+
+const normalizeConfig = (value: unknown): Partial<PlayerConfig> | null => {
+  if (!value || typeof value !== 'object') return null
+  const data = value as Record<string, unknown>
+  const result: Partial<PlayerConfig> = {}
+
+  if (isGameMode(data.gameMode)) result.gameMode = data.gameMode
+  if (isColorChoice(data.colorChoice)) result.colorChoice = data.colorChoice
+  if (typeof data.elo === 'number' && Number.isFinite(data.elo)) {
+    result.elo = snapMaiaElo(data.elo)
+  }
+  if (isBoardThemeKey(data.boardTheme)) result.boardTheme = data.boardTheme
+
+  if (data.takebackLimit === null) {
+    result.takebackLimit = Infinity
+  } else if (typeof data.takebackLimit === 'number' && Number.isFinite(data.takebackLimit)) {
+    result.takebackLimit = Math.max(0, Math.floor(data.takebackLimit))
+  }
+
+  if (typeof data.allowEloChangeMidGame === 'boolean') {
+    result.allowEloChangeMidGame = data.allowEloChangeMidGame
+  }
+
+  return result
+}
+
+const toStoredConfig = (config: PlayerConfig): StoredPlayerConfig => ({
+  ...config,
+  takebackLimit:
+    config.takebackLimit === Infinity
+      ? null
+      : Math.max(0, Math.floor(config.takebackLimit)),
+})
+
+export const loadPlayerConfig = async (): Promise<Partial<PlayerConfig> | null> => {
+  const ipc = getIpcRenderer()
+  if (ipc) {
+    try {
+      const data = await ipc.invoke('config:read')
+      return normalizeConfig(data)
+    } catch {
+      return null
+    }
+  }
+
+  try {
+    const raw = localStorage.getItem(LOCAL_STORAGE_KEY)
+    if (!raw) return null
+    return normalizeConfig(JSON.parse(raw))
+  } catch {
+    return null
+  }
+}
+
+export const savePlayerConfig = async (config: PlayerConfig): Promise<void> => {
+  const payload: StoredPlayerConfig = toStoredConfig(config)
+
+  const ipc = getIpcRenderer()
+  if (ipc) {
+    await ipc.invoke('config:write', payload)
+    return
+  }
+
+  try {
+    localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(payload))
+  } catch {
+    // Ignore storage failures in browser mode.
+  }
+}