@myrialabs/clopen 0.0.1

package/frontend/lib/stores/features/claude-accounts.svelte.ts

@@ -0,0 +1,58 @@
+/**
+ * Claude Accounts Store
+ *
+ * Shared reactive store for Claude Code accounts.
+ * Used by both AIEnginesSettings and EngineModelPicker to stay in sync.
+ * Fetches from backend via `engine:claude-accounts-list`.
+ */
+
+import ws from '$frontend/lib/utils/ws';
+import { debug } from '$shared/utils/logger';
+
+export interface ClaudeAccountItem {
+	id: number;
+	name: string;
+	isActive: boolean;
+	createdAt: string;
+}
+
+let accounts = $state<ClaudeAccountItem[]>([]);
+let loaded = $state(false);
+
+export const claudeAccountsStore = {
+	get accounts() { return accounts; },
+	get loaded() { return loaded; },
+
+	/** Fetch accounts from backend. Idempotent — skips if already loaded. */
+	async fetch(): Promise<ClaudeAccountItem[]> {
+		if (loaded) return accounts;
+		return this.refresh();
+	},
+
+	/** Force re-fetch accounts from backend. */
+	async refresh(): Promise<ClaudeAccountItem[]> {
+		try {
+			const result = await ws.http('engine:claude-accounts-list', {});
+			accounts = result.accounts;
+			loaded = true;
+			debug.log('settings', `Claude accounts loaded: ${accounts.length}`);
+			return accounts;
+		} catch {
+			accounts = [];
+			loaded = true;
+			return [];
+		}
+	},
+
+	/** Update accounts list directly (avoids round-trip to backend). */
+	set(newAccounts: ClaudeAccountItem[]) {
+		accounts = newAccounts;
+		loaded = true;
+	},
+
+	/** Reset store state. */
+	reset() {
+		accounts = [];
+		loaded = false;
+	}
+};

package/frontend/lib/stores/features/models.svelte.ts

@@ -0,0 +1,89 @@
+/**
+ * Models Store with Svelte 5 Runes
+ *
+ * Manages available AI models per engine.
+ * All engines (Claude Code and Open Code) fetch models dynamically
+ * from the backend via `models:list` endpoint.
+ */
+
+import { CLAUDE_CODE_MODELS, registerModels } from '$shared/constants/engines';
+import type { EngineModel, EngineType } from '$shared/types/engine';
+import ws from '$frontend/lib/utils/ws';
+
+import { debug } from '$shared/utils/logger';
+
+// Reactive state — start with static fallback until first fetch completes
+let models = $state<EngineModel[]>([...CLAUDE_CODE_MODELS]);
+let loading = $state(false);
+let fetchedEngines = $state<Set<EngineType>>(new Set());
+
+export const modelStore = {
+	get models() { return models; },
+	get loading() { return loading; },
+
+	/** Get models filtered by engine */
+	getByEngine(engine: EngineType): EngineModel[] {
+		return models.filter(m => m.engine === engine);
+	},
+
+	/** Get a model by its compound ID */
+	getById(modelId: string): EngineModel | undefined {
+		return models.find(m => m.id === modelId);
+	},
+
+	/**
+	 * Fetch models for a specific engine from the backend.
+	 * Uses cache by default — call refreshModels() to bypass.
+	 */
+	async fetchModels(engine: EngineType): Promise<EngineModel[]> {
+		// Skip if already fetched for this engine
+		if (fetchedEngines.has(engine)) {
+			const existing = models.filter(m => m.engine === engine);
+			if (existing.length > 0) return existing;
+		}
+
+		return this._doFetch(engine);
+	},
+
+	/**
+	 * Force re-fetch models for an engine, bypassing cache.
+	 */
+	async refreshModels(engine: EngineType): Promise<EngineModel[]> {
+		return this._doFetch(engine);
+	},
+
+	/** Internal fetch logic shared by fetchModels and refreshModels */
+	async _doFetch(engine: EngineType): Promise<EngineModel[]> {
+		loading = true;
+		try {
+			const fetched = await ws.http('models:list', { engine });
+			const engineModels = fetched as EngineModel[];
+
+			// Update shared registry
+			registerModels(engine, engineModels);
+
+			// Update local reactive state: replace models for this engine
+			const otherModels = models.filter(m => m.engine !== engine);
+			models = [...otherModels, ...engineModels];
+			fetchedEngines = new Set([...fetchedEngines, engine]);
+
+			debug.log('settings', `Fetched ${engineModels.length} models for ${engine}`);
+			return engineModels;
+		} catch (error) {
+			debug.error('settings', `Failed to fetch models for ${engine}:`, error);
+			// For claude-code, return static fallback on fetch failure
+			if (engine === 'claude-code') {
+				return CLAUDE_CODE_MODELS;
+			}
+			return [];
+		} finally {
+			loading = false;
+		}
+	},
+
+	/** Reset to only static models */
+	reset(): void {
+		models = [...CLAUDE_CODE_MODELS];
+		fetchedEngines = new Set();
+	}
+};

package/frontend/lib/stores/features/settings.svelte.ts

@@ -0,0 +1,87 @@
+/**
+ * Settings Store with Svelte 5 Runes
+ *
+ * Centralized store for user settings with server-side persistence
+ * Settings are stored on the server via user:save-state / user:restore-state
+ * No localStorage usage - server is single source of truth
+ */
+
+import { DEFAULT_MODEL, DEFAULT_ENGINE } from '$shared/constants/engines';
+import type { AppSettings } from '$shared/types/stores/settings';
+import { builtInPresets } from '$frontend/lib/stores/ui/workspace.svelte';
+import ws from '$frontend/lib/utils/ws';
+
+import { debug } from '$shared/utils/logger';
+
+// Create default visibility map (all presets visible by default)
+const createDefaultPresetVisibility = (): Record<string, boolean> => {
+	const visibility: Record<string, boolean> = {};
+	builtInPresets.forEach((preset) => {
+		visibility[preset.id] = true;
+	});
+	return visibility;
+};
+
+// Default settings
+const defaultSettings: AppSettings = {
+	selectedEngine: DEFAULT_ENGINE,
+	selectedModel: DEFAULT_MODEL,
+	engineModelMemory: { 'claude-code': DEFAULT_MODEL },
+	autoSave: true,
+	theme: 'system',
+	soundNotifications: true,
+	pushNotifications: false,
+	layoutPresetVisibility: createDefaultPresetVisibility(),
+	allowedBasePaths: []
+};
+
+// Create and export reactive settings state directly (starts with defaults)
+export const settings = $state<AppSettings>({ ...defaultSettings });
+
+/**
+ * Apply server-provided settings during initialization.
+ * Called from WorkspaceLayout with state from user:restore-state.
+ */
+export function applyServerSettings(serverSettings: Partial<AppSettings> | null): void {
+	if (serverSettings && typeof serverSettings === 'object') {
+		// Merge with defaults to ensure all properties exist
+		Object.assign(settings, { ...defaultSettings, ...serverSettings });
+		debug.log('settings', 'Applied server settings');
+	}
+}
+
+// Save settings to server (fire-and-forget)
+function saveSettings(): void {
+	ws.http('user:save-state', { key: 'settings', value: { ...settings } }).catch(err => {
+		debug.error('settings', 'Failed to save settings to server:', err);
+	});
+}
+
+// Export functions directly
+export function updateSettings(newSettings: Partial<AppSettings>) {
+	Object.assign(settings, newSettings);
+	saveSettings();
+}
+
+export function resetToDefaults() {
+	Object.assign(settings, defaultSettings);
+	saveSettings();
+}
+
+export function exportSettings(): string {
+	return JSON.stringify(settings, null, 2);
+}
+
+export function importSettings(settingsJson: string): boolean {
+	try {
+		const imported = JSON.parse(settingsJson);
+		// Validate basic structure
+		if (typeof imported === 'object' && imported !== null) {
+			updateSettings(imported);
+			return true;
+		}
+	} catch (error) {
+		debug.error('settings', 'Failed to import settings:', error);
+	}
+	return false;
+}