fix(desktop): persist configurable storage paths

Author: Sun-sunshine06

apps/desktop/electron-builder.yml

@@ -50,6 +50,9 @@ win:
   target:
     - target: nsis
       arch: [x64, arm64]
+nsis:
+  oneClick: false
+  allowToChangeInstallationDirectory: true
 linux:
   icon: resources/icon.png
   target:

apps/desktop/src/main/config.ts

@@ -9,15 +9,20 @@ import {
   toPersistedV3,
 } from '@open-codesign/shared';
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
+import { getActiveStorageLocations } from './storage-settings';
 
 const XDG_DEFAULT = join(homedir(), '.config', 'open-codesign');
 
-export function configDir(): string {
+export function defaultConfigDir(): string {
   const xdg = process.env['XDG_CONFIG_HOME'];
   if (xdg && xdg.length > 0) return join(xdg, 'open-codesign');
   return XDG_DEFAULT;
 }
 
+export function configDir(): string {
+  return getActiveStorageLocations().configDir ?? defaultConfigDir();
+}
+
 export function configPath(): string {
   return join(configDir(), 'config.toml');
 }

apps/desktop/src/main/index.ts

@@ -1,3 +1,4 @@
+import { mkdirSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -47,6 +48,7 @@ import { preparePromptContext } from './prompt-context';
 import { isKeylessProviderAllowed, resolveActiveModel } from './provider-settings';
 import { safeInitSnapshotsDb } from './snapshots-db';
 import { registerSnapshotsIpc, registerSnapshotsUnavailableIpc } from './snapshots-ipc';
+import { initStorageSettings } from './storage-settings';
 
 // ESM shim: package.json "type": "module" means the built bundle is ESM and
 // __dirname/__filename don't exist. Derive them from import.meta.url so the
@@ -56,6 +58,13 @@ const __dirname = dirname(__filename);
 
 let mainWindow: ElectronBrowserWindow | null = null;
 
+const defaultUserDataDir = app.getPath('userData');
+const storageLocations = initStorageSettings(defaultUserDataDir);
+if (storageLocations.dataDir !== undefined) {
+  mkdirSync(storageLocations.dataDir, { recursive: true });
+  app.setPath('userData', storageLocations.dataDir);
+}
+
 /**
  * Workstream B Phase 1 feature flag. When truthy, `codesign:*:generate` routes
  * through `generateViaAgent()` (pi-agent-core, zero tools). Default off — any

apps/desktop/src/main/logger.ts

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import log from 'electron-log/main';
 import { app } from './electron-runtime';
+import { getActiveStorageLocations } from './storage-settings';
 
 /**
  * Centralized logger for the main + preload + renderer processes.
@@ -19,11 +20,19 @@ import { app } from './electron-runtime';
 
 let initialized = false;
 
+export function defaultLogsDir(): string {
+  return app.getPath('logs');
+}
+
+export function logsDir(): string {
+  return getActiveStorageLocations().logsDir ?? defaultLogsDir();
+}
+
 export function initLogger(): typeof log {
   if (initialized) return log;
   initialized = true;
 
-  log.transports.file.resolvePathFn = () => join(app.getPath('logs'), 'main.log');
+  log.transports.file.resolvePathFn = () => getLogPath();
   log.transports.file.maxSize = 5 * 1024 * 1024; // 5MB
   log.transports.file.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {scope} {text}';
   log.transports.console.level = app.isPackaged ? 'warn' : 'info';
@@ -59,5 +68,5 @@ export function getLogger(scope: string) {
 }
 
 export function getLogPath(): string {
-  return join(app.getPath('logs'), 'main.log');
+  return join(logsDir(), 'main.log');
 }

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

@@ -21,6 +21,7 @@ vi.mock('./electron-runtime', () => ({
       handlers.set(channel, fn);
     },
   },
+  dialog: { showOpenDialog: vi.fn(async () => ({ canceled: true, filePaths: [] })) },
   shell: { openPath: vi.fn() },
 }));
 
@@ -50,8 +51,7 @@ vi.mock('electron-log/main', () => ({
 }));
 
 vi.mock('./config', () => ({
-  configPath: () => '/tmp/config.toml',
-  configDir: () => '/tmp',
+  defaultConfigDir: () => '/tmp/config',
   readConfig: vi.fn(async () => null),
   writeConfig: vi.fn(async () => {}),
 }));
@@ -82,7 +82,28 @@ vi.mock('./keychain-ux', () => ({
 }));
 
 vi.mock('./storage-settings', () => ({
-  buildAppPaths: vi.fn(() => ({})),
+  buildAppPathsForLocations: vi.fn(() => ({})),
+  getDefaultUserDataDir: vi.fn(() => '/tmp/data'),
+  patchForStorageKind: vi.fn((kind: string, dir: string) => ({ [`${kind}Dir`]: dir })),
+  readPersistedStorageLocations: vi.fn(async () => ({})),
+  writeStorageLocations: vi.fn(async () => ({})),
+}));
+
+vi.mock('./logger', () => ({
+  defaultLogsDir: () => '/tmp/logs',
+  getLogger: () => ({
+    warn: vi.fn(),
+    info: vi.fn(),
+    error: vi.fn(),
+  }),
+}));
+
+vi.mock('./imports/codex-config', () => ({
+  readCodexConfig: vi.fn(async () => null),
+}));
+
+vi.mock('./imports/claude-code-config', () => ({
+  readClaudeCodeSettings: vi.fn(async () => null),
 }));
 
 vi.mock('@open-codesign/providers', () => ({
@@ -99,13 +120,14 @@ describe('registerOnboardingIpc — channel versioning', () => {
     expect(registeredChannels).toContain('settings:list-providers');
   });
 
-  it('registers all eight settings v1 channels', async () => {
+  it('registers all settings v1 channels', async () => {
     const v1Channels = [
       'settings:v1:list-providers',
       'settings:v1:add-provider',
       'settings:v1:delete-provider',
       'settings:v1:set-active-provider',
       'settings:v1:get-paths',
+      'settings:v1:choose-storage-folder',
       'settings:v1:open-folder',
       'settings:v1:reset-onboarding',
       'settings:v1:toggle-devtools',
@@ -116,13 +138,14 @@ describe('registerOnboardingIpc — channel versioning', () => {
     }
   });
 
-  it('preserves all eight legacy settings shim channels for backward compat', async () => {
+  it('preserves all legacy settings shim channels for backward compat', async () => {
     const legacyChannels = [
       'settings:list-providers',
       'settings:add-provider',
       'settings:delete-provider',
       'settings:set-active-provider',
       'settings:get-paths',
+      'settings:choose-storage-folder',
       'settings:open-folder',
       'settings:reset-onboarding',
       'settings:toggle-devtools',
@@ -240,3 +263,43 @@ describe('getApiKeyForProvider — API key retrieval', () => {
     expect(() => getApiKeyForProvider('openai')).toThrow(/PROVIDER_KEY_MISSING|No API key stored/);
   });
 });
+
+describe('config:v1:import-codex-config empty env handling', () => {
+  it('imports providers without encrypting empty env secrets', async () => {
+    const { readCodexConfig } = await import('./imports/codex-config');
+    const { encryptSecret } = await import('./keychain');
+    const { writeConfig } = await import('./config');
+    vi.mocked(encryptSecret).mockClear();
+    vi.mocked(writeConfig).mockClear();
+    vi.mocked(readCodexConfig).mockResolvedValueOnce({
+      providers: [
+        {
+          id: 'codex-empty-env',
+          name: 'Codex (imported)',
+          builtin: false,
+          wire: 'openai-chat',
+          baseUrl: 'https://api.example.com/v1',
+          defaultModel: 'gpt-test',
+          envKey: 'OPEN_CODESIGN_EMPTY_ENV_FOR_TEST',
+        },
+      ],
+      activeProvider: 'codex-empty-env',
+      activeModel: 'gpt-test',
+      envKeyMap: { 'codex-empty-env': 'OPEN_CODESIGN_EMPTY_ENV_FOR_TEST' },
+      warnings: [],
+    });
+    process.env['OPEN_CODESIGN_EMPTY_ENV_FOR_TEST'] = '   ';
+
+    const handler = handlers.get('config:v1:import-codex-config');
+    expect(handler).toBeDefined();
+    await expect(handler?.({} as unknown)).resolves.toMatchObject({
+      provider: 'codex-empty-env',
+      hasKey: true,
+    });
+
+    expect(encryptSecret).not.toHaveBeenCalled();
+    const written = vi.mocked(writeConfig).mock.calls.at(-1)?.[0];
+    expect(written?.secrets['codex-empty-env']).toBeUndefined();
+    delete process.env['OPEN_CODESIGN_EMPTY_ENV_FOR_TEST'];
+  });
+});

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

@@ -14,13 +14,13 @@ import {
   hydrateConfig,
   isSupportedOnboardingProvider,
 } from '@open-codesign/shared';
-import { configDir, configPath, readConfig, writeConfig } from './config';
-import { ipcMain, shell } from './electron-runtime';
+import { defaultConfigDir, readConfig, writeConfig } from './config';
+import { dialog, ipcMain, shell } from './electron-runtime';
 import { type ClaudeCodeImport, readClaudeCodeSettings } from './imports/claude-code-config';
 import { type CodexImport, readCodexConfig } from './imports/codex-config';
 import { buildSecretRef, decryptSecret, migrateSecretMasks, tryBuildSecretRef } from './keychain';
 import { prepareKeychain } from './keychain-ux';
-import { getLogPath, getLogger } from './logger';
+import { defaultLogsDir, getLogger } from './logger';
 import {
   type ProviderRow,
   assertProviderHasStoredSecret,
@@ -29,7 +29,15 @@ import {
   isKeylessProviderAllowed,
   toProviderRows,
 } from './provider-settings';
-import { buildAppPaths } from './storage-settings';
+import {
+  type AppPaths,
+  type StorageKind,
+  buildAppPathsForLocations,
+  getDefaultUserDataDir,
+  patchForStorageKind,
+  readPersistedStorageLocations,
+  writeStorageLocations,
+} from './storage-settings';
 
 const logger = getLogger('settings-ipc');
 
@@ -387,8 +395,42 @@ async function runSetActiveProvider(raw: unknown): Promise<OnboardingState> {
   return toState(cachedConfig);
 }
 
-function runGetPaths() {
-  return buildAppPaths(configPath(), getLogPath(), configDir());
+function defaultDataDir(): string {
+  return getDefaultUserDataDir();
+}
+
+function getStoragePathDefaults() {
+  return {
+    configDir: defaultConfigDir(),
+    logsDir: defaultLogsDir(),
+    dataDir: defaultDataDir(),
+  };
+}
+
+async function runGetPaths(): Promise<AppPaths> {
+  const persisted = await readPersistedStorageLocations();
+  return buildAppPathsForLocations(persisted, getStoragePathDefaults());
+}
+
+function parseStorageKind(raw: unknown): StorageKind {
+  if (raw === 'config' || raw === 'logs' || raw === 'data') return raw;
+  throw new CodesignError('storage kind must be "config", "logs", or "data"', 'IPC_BAD_INPUT');
+}
+
+async function runChooseStorageFolder(raw: unknown): Promise<AppPaths> {
+  const kind = parseStorageKind(raw);
+  const result = await dialog.showOpenDialog({
+    properties: ['openDirectory', 'createDirectory'],
+  });
+  if (result.canceled || result.filePaths.length === 0) {
+    return runGetPaths();
+  }
+  const selected = result.filePaths[0];
+  if (selected === undefined || selected.trim().length === 0) {
+    return runGetPaths();
+  }
+  await writeStorageLocations(patchForStorageKind(kind, selected));
+  return runGetPaths();
 }
 
 async function runOpenFolder(raw: unknown): Promise<void> {
@@ -636,7 +678,7 @@ async function runImportCodex(imported: CodexImport): Promise<OnboardingState> {
   for (const entry of imported.providers) {
     nextProviders[entry.id] = entry;
     if (entry.envKey !== undefined) {
-      const envValue = process.env[entry.envKey];
+      const envValue = process.env[entry.envKey]?.trim();
       if (envValue !== undefined && envValue.length > 0) {
         const ref = tryBuildSecretRef(envValue);
         if (ref !== null) nextSecrets[entry.id] = ref;
@@ -680,8 +722,9 @@ async function runImportClaudeCode(imported: ClaudeCodeImport): Promise<Onboardi
     }
   }
   nextProviders[imported.provider.id] = imported.provider;
-  if (imported.apiKey !== null) {
-    const ref = tryBuildSecretRef(imported.apiKey);
+  const importedApiKey = imported.apiKey?.trim();
+  if (importedApiKey !== undefined && importedApiKey.length > 0) {
+    const ref = tryBuildSecretRef(importedApiKey);
     if (ref !== null) nextSecrets[imported.provider.id] = ref;
   }
   const next = hydrateConfig({
@@ -891,7 +934,12 @@ export function registerOnboardingIpc(): void {
     async (_e, raw: unknown): Promise<OnboardingState> => runSetActiveProvider(raw),
   );
 
-  ipcMain.handle('settings:v1:get-paths', () => runGetPaths());
+  ipcMain.handle('settings:v1:get-paths', async (): Promise<AppPaths> => runGetPaths());
+
+  ipcMain.handle(
+    'settings:v1:choose-storage-folder',
+    async (_e, raw: unknown): Promise<AppPaths> => runChooseStorageFolder(raw),
+  );
 
   ipcMain.handle(
     'settings:v1:open-folder',
@@ -929,11 +977,16 @@ export function registerOnboardingIpc(): void {
     },
   );
 
-  ipcMain.handle('settings:get-paths', () => {
+  ipcMain.handle('settings:get-paths', async (): Promise<AppPaths> => {
     logger.warn('legacy settings:get-paths channel used, schedule removal next minor');
     return runGetPaths();
   });
 
+  ipcMain.handle('settings:choose-storage-folder', async (_e, raw: unknown): Promise<AppPaths> => {
+    logger.warn('legacy settings:choose-storage-folder channel used, schedule removal next minor');
+    return runChooseStorageFolder(raw);
+  });
+
   ipcMain.handle('settings:open-folder', async (_e, raw: unknown) => {
     logger.warn('legacy settings:open-folder channel used, schedule removal next minor');
     return runOpenFolder(raw);