feat(desktop): implement settings tabs with multi-provider management

Replace all four "Coming soon" stub tabs with fully functional settings UI.

Models tab: list saved API providers with masked keys and base URLs, add new
providers via a modal with inline key validation, switch active provider,
configure per-provider primary/fast model selection, and delete providers with
an inline confirm step.

Appearance tab: light/dark theme segmented control plus language selector.

Storage tab: display config / log / data-dir paths with copy and open-folder
buttons; reset-onboarding action with confirmation.

Advanced tab: update channel selector, generation timeout input, and a
toggle-DevTools button.

New IPC channels added to onboarding-ipc.ts:
  settings:list-providers, settings:add-provider, settings:delete-provider,
  settings:set-active-provider, settings:get-paths, settings:open-folder,
  settings:reset-onboarding, settings:toggle-devtools

New preload surface: window.codesign.settings.*

Author: hqhq1025

apps/desktop/src/main/onboarding-ipc.ts

@@ -6,9 +6,10 @@ import {
   type SupportedOnboardingProvider,
   isSupportedOnboardingProvider,
 } from '@open-codesign/shared';
-import { ipcMain } from 'electron';
-import { readConfig, writeConfig } from './config';
+import { ipcMain, shell } from 'electron';
+import { configDir, configPath, readConfig, writeConfig } from './config';
 import { decryptSecret, encryptSecret } from './keychain';
+import { getLogPath } from './logger';
 
 interface SaveKeyInput {
   provider: SupportedOnboardingProvider;
@@ -24,6 +25,14 @@ interface ValidateKeyInput {
   baseUrl?: string;
 }
 
+/** Summarised row returned to the renderer for each stored provider. */
+export interface ProviderRow {
+  provider: SupportedOnboardingProvider;
+  maskedKey: string;
+  baseUrl: string | null;
+  isActive: boolean;
+}
+
 let cachedConfig: Config | null = null;
 let configLoaded = false;
 
@@ -61,6 +70,13 @@ export function getBaseUrlForProvider(provider: string): string | undefined {
   return ref?.baseUrl;
 }
 
+function maskKey(plain: string): string {
+  if (plain.length <= 8) return '***';
+  const prefix = plain.startsWith('sk-') ? 'sk-' : plain.slice(0, 4);
+  const suffix = plain.slice(-4);
+  return `${prefix}***${suffix}`;
+}
+
 function toState(cfg: Config | null): OnboardingState {
   if (cfg === null) {
     return { hasKey: false, provider: null, modelPrimary: null, modelFast: null, baseUrl: null };
@@ -87,6 +103,27 @@ function toState(cfg: Config | null): OnboardingState {
   };
 }
 
+function toProviderRows(cfg: Config | null): ProviderRow[] {
+  if (cfg === null) return [];
+  const rows: ProviderRow[] = [];
+  for (const [p, ref] of Object.entries(cfg.secrets)) {
+    if (!isSupportedOnboardingProvider(p) || ref === undefined) continue;
+    let plain: string;
+    try {
+      plain = decryptSecret(ref.ciphertext);
+    } catch {
+      plain = '';
+    }
+    rows.push({
+      provider: p,
+      maskedKey: maskKey(plain),
+      baseUrl: cfg.baseUrls?.[p as SupportedOnboardingProvider]?.baseUrl ?? null,
+      isActive: cfg.provider === p,
+    });
+  }
+  return rows;
+}
+
 function parseSaveKey(raw: unknown): SaveKeyInput {
   if (typeof raw !== 'object' || raw === null) {
     throw new CodesignError('save-key expects an object payload', 'IPC_BAD_INPUT');
@@ -186,4 +223,138 @@ export function registerOnboardingIpc(): void {
   ipcMain.handle('onboarding:skip', async (): Promise<OnboardingState> => {
     return toState(cachedConfig);
   });
+
+  // ── Settings: provider management ──────────────────────────────────────────
+
+  ipcMain.handle('settings:list-providers', (): ProviderRow[] => {
+    return toProviderRows(getCachedConfig());
+  });
+
+  ipcMain.handle('settings:add-provider', async (_e, raw: unknown): Promise<ProviderRow[]> => {
+    const input = parseSaveKey(raw);
+    const ciphertext = encryptSecret(input.apiKey);
+    const nextBaseUrls = { ...(cachedConfig?.baseUrls ?? {}) };
+    if (input.baseUrl !== undefined) {
+      nextBaseUrls[input.provider] = { baseUrl: input.baseUrl };
+    } else {
+      delete nextBaseUrls[input.provider];
+    }
+    // When adding the first provider, make it active.
+    const activeProvider =
+      cachedConfig !== null && isSupportedOnboardingProvider(cachedConfig.provider)
+        ? cachedConfig.provider
+        : input.provider;
+    const next: Config = {
+      version: 1,
+      provider: activeProvider,
+      modelPrimary: cachedConfig?.modelPrimary ?? input.modelPrimary,
+      modelFast: cachedConfig?.modelFast ?? input.modelFast,
+      secrets: {
+        ...(cachedConfig?.secrets ?? {}),
+        [input.provider]: { ciphertext },
+      },
+      baseUrls: nextBaseUrls,
+    };
+    await writeConfig(next);
+    cachedConfig = next;
+    return toProviderRows(cachedConfig);
+  });
+
+  ipcMain.handle('settings:delete-provider', async (_e, raw: unknown): Promise<ProviderRow[]> => {
+    if (typeof raw !== 'string' || !isSupportedOnboardingProvider(raw)) {
+      throw new CodesignError('delete-provider expects a provider string', 'IPC_BAD_INPUT');
+    }
+    const cfg = getCachedConfig();
+    if (cfg === null) return [];
+    const nextSecrets = { ...cfg.secrets };
+    delete nextSecrets[raw];
+    const nextBaseUrls = { ...(cfg.baseUrls ?? {}) };
+    delete nextBaseUrls[raw];
+    // If we deleted the active provider, switch to first remaining one.
+    const remaining = Object.keys(nextSecrets).filter(isSupportedOnboardingProvider);
+    const nextActive = cfg.provider === raw ? (remaining[0] ?? 'openai') : cfg.provider;
+    if (!isSupportedOnboardingProvider(nextActive)) {
+      throw new CodesignError('No valid active provider after deletion', 'PROVIDER_NOT_SUPPORTED');
+    }
+    const next: Config = {
+      version: 1,
+      provider: nextActive,
+      modelPrimary: cfg.modelPrimary,
+      modelFast: cfg.modelFast,
+      secrets: nextSecrets,
+      baseUrls: nextBaseUrls,
+    };
+    await writeConfig(next);
+    cachedConfig = next;
+    return toProviderRows(cachedConfig);
+  });
+
+  ipcMain.handle(
+    'settings:set-active-provider',
+    async (_e, raw: unknown): Promise<OnboardingState> => {
+      if (typeof raw !== 'object' || raw === null) {
+        throw new CodesignError('set-active-provider expects an object', 'IPC_BAD_INPUT');
+      }
+      const r = raw as Record<string, unknown>;
+      const provider = r['provider'];
+      const modelPrimary = r['modelPrimary'];
+      const modelFast = r['modelFast'];
+      if (typeof provider !== 'string' || !isSupportedOnboardingProvider(provider)) {
+        throw new CodesignError('provider must be a supported provider string', 'IPC_BAD_INPUT');
+      }
+      if (typeof modelPrimary !== 'string' || modelPrimary.trim().length === 0) {
+        throw new CodesignError('modelPrimary must be a non-empty string', 'IPC_BAD_INPUT');
+      }
+      if (typeof modelFast !== 'string' || modelFast.trim().length === 0) {
+        throw new CodesignError('modelFast must be a non-empty string', 'IPC_BAD_INPUT');
+      }
+      const cfg = getCachedConfig();
+      if (cfg === null) {
+        throw new CodesignError('No configuration found', 'CONFIG_MISSING');
+      }
+      const next: Config = {
+        ...cfg,
+        provider,
+        modelPrimary,
+        modelFast,
+      };
+      await writeConfig(next);
+      cachedConfig = next;
+      return toState(cachedConfig);
+    },
+  );
+
+  // ── Settings: storage helpers ───────────────────────────────────────────────
+
+  ipcMain.handle('settings:get-paths', () => ({
+    config: configPath(),
+    logs: getLogPath(),
+    data: configDir(),
+  }));
+
+  ipcMain.handle('settings:open-folder', async (_e, raw: unknown) => {
+    if (typeof raw !== 'string') {
+      throw new CodesignError('open-folder expects a path string', 'IPC_BAD_INPUT');
+    }
+    await shell.openPath(raw);
+  });
+
+  ipcMain.handle('settings:reset-onboarding', async (): Promise<void> => {
+    const cfg = getCachedConfig();
+    if (cfg === null) return;
+    // Clear secrets so onboarding flow triggers again on next load.
+    const next: Config = {
+      ...cfg,
+      secrets: {},
+    };
+    await writeConfig(next);
+    cachedConfig = next;
+  });
+
+  // ── Settings: appearance / advanced ────────────────────────────────────────
+
+  ipcMain.handle('settings:toggle-devtools', (_e) => {
+    // We need the webContents reference — the event sender is the renderer.
+    _e.sender.toggleDevTools();
+  });
 }

apps/desktop/src/preload/index.ts

@@ -23,6 +23,19 @@ export interface ExportInvokeResponse {
   bytes?: number;
 }
 
+export interface ProviderRow {
+  provider: SupportedOnboardingProvider;
+  maskedKey: string;
+  baseUrl: string | null;
+  isActive: boolean;
+}
+
+export interface AppPaths {
+  config: string;
+  logs: string;
+  data: string;
+}
+
 const api = {
   detectProvider: (key: string) =>
     ipcRenderer.invoke('codesign:detect-provider', key) as Promise<string | null>,
@@ -61,6 +74,35 @@ const api = {
     }) => ipcRenderer.invoke('onboarding:save-key', input) as Promise<OnboardingState>,
     skip: () => ipcRenderer.invoke('onboarding:skip') as Promise<OnboardingState>,
   },
+  settings: {
+    listProviders: () => ipcRenderer.invoke('settings:list-providers') as Promise<ProviderRow[]>,
+    addProvider: (input: {
+      provider: SupportedOnboardingProvider;
+      apiKey: string;
+      modelPrimary: string;
+      modelFast: string;
+      baseUrl?: string;
+    }) => ipcRenderer.invoke('settings:add-provider', input) as Promise<ProviderRow[]>,
+    deleteProvider: (provider: SupportedOnboardingProvider) =>
+      ipcRenderer.invoke('settings:delete-provider', provider) as Promise<ProviderRow[]>,
+    setActiveProvider: (input: {
+      provider: SupportedOnboardingProvider;
+      modelPrimary: string;
+      modelFast: string;
+    }) => ipcRenderer.invoke('settings:set-active-provider', input) as Promise<OnboardingState>,
+    getPaths: () => ipcRenderer.invoke('settings:get-paths') as Promise<AppPaths>,
+    openFolder: (path: string) => ipcRenderer.invoke('settings:open-folder', path) as Promise<void>,
+    resetOnboarding: () => ipcRenderer.invoke('settings:reset-onboarding') as Promise<void>,
+    toggleDevtools: () => ipcRenderer.invoke('settings:toggle-devtools') as Promise<void>,
+    validateKey: (input: {
+      provider: SupportedOnboardingProvider;
+      apiKey: string;
+      baseUrl?: string;
+    }) =>
+      ipcRenderer.invoke('onboarding:validate-key', input) as Promise<
+        ValidateKeyResult | ValidateKeyError
+      >,
+  },
 };
 
 contextBridge.exposeInMainWorld('codesign', api);