claudedesk 4.3.1 → 4.4.0

package/dist/main/model-history-manager.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelHistoryManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const uuid_1 = require("uuid");
+class ModelHistoryManager {
+    constructor() {
+        this.pendingWrite = null;
+        this.lastSwitchBySession = new Map();
+        const userDataPath = electron_1.app.getPath('userData');
+        const historyDir = path.join(userDataPath, 'model-history');
+        // Ensure directory exists
+        if (!fs.existsSync(historyDir)) {
+            fs.mkdirSync(historyDir, { recursive: true });
+        }
+        this.indexPath = path.join(historyDir, 'index.json');
+        this.index = this.loadIndex();
+    }
+    loadIndex() {
+        try {
+            if (fs.existsSync(this.indexPath)) {
+                const data = fs.readFileSync(this.indexPath, 'utf-8');
+                const loaded = JSON.parse(data);
+                // Validate structure
+                if (loaded.version === 1 && loaded.entries && loaded.bySession) {
+                    return loaded;
+                }
+            }
+        }
+        catch (err) {
+            console.error('[ModelHistoryManager] Failed to load index:', err);
+        }
+        // Return empty index if file doesn't exist or is invalid
+        return {
+            version: 1,
+            entries: {},
+            bySession: {},
+        };
+    }
+    scheduleWrite() {
+        if (this.pendingWrite) {
+            clearTimeout(this.pendingWrite);
+        }
+        // Debounce writes (1 second)
+        this.pendingWrite = setTimeout(() => {
+            this.flushToDisk();
+            this.pendingWrite = null;
+        }, 1000);
+    }
+    flushToDisk() {
+        try {
+            const tmpPath = `${this.indexPath}.tmp`;
+            const data = JSON.stringify(this.index, null, 2);
+            // Atomic write: write to temp file, then rename
+            fs.writeFileSync(tmpPath, data, 'utf-8');
+            fs.renameSync(tmpPath, this.indexPath);
+        }
+        catch (err) {
+            console.error('[ModelHistoryManager] Failed to write index:', err);
+        }
+    }
+    /**
+     * Log a model switch event
+     */
+    logSwitch(event) {
+        const { sessionId, model, previousModel, detectedAt } = event;
+        // Calculate duration if we have a previous switch for this session
+        let durationMs;
+        const lastSwitch = this.lastSwitchBySession.get(sessionId);
+        if (lastSwitch) {
+            durationMs = detectedAt - lastSwitch.timestamp;
+        }
+        // Create entry
+        const entry = {
+            id: (0, uuid_1.v4)(),
+            sessionId,
+            timestamp: detectedAt,
+            fromModel: previousModel,
+            toModel: model,
+            durationMs,
+        };
+        // Add to index
+        this.index.entries[entry.id] = entry;
+        // Add to session's chronological list
+        if (!this.index.bySession[sessionId]) {
+            this.index.bySession[sessionId] = [];
+        }
+        this.index.bySession[sessionId].push(entry.id);
+        // Update last switch tracker
+        this.lastSwitchBySession.set(sessionId, {
+            timestamp: detectedAt,
+            model,
+        });
+        // Schedule write
+        this.scheduleWrite();
+    }
+    /**
+     * Get all model switch history for a session (chronological order)
+     */
+    getHistory(sessionId) {
+        const entryIds = this.index.bySession[sessionId] || [];
+        return entryIds
+            .map(id => this.index.entries[id])
+            .filter(entry => entry !== undefined)
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Clear history for a specific session
+     */
+    clearHistory(sessionId) {
+        const entryIds = this.index.bySession[sessionId] || [];
+        // Remove entries
+        for (const id of entryIds) {
+            delete this.index.entries[id];
+        }
+        // Remove session list
+        delete this.index.bySession[sessionId];
+        // Remove from last switch tracker
+        this.lastSwitchBySession.delete(sessionId);
+        // Schedule write
+        this.scheduleWrite();
+    }
+    /**
+     * Get statistics for a session
+     */
+    getStats(sessionId) {
+        const history = this.getHistory(sessionId);
+        const switchCount = history.length;
+        if (switchCount === 0) {
+            return { switchCount: 0, avgDurationMs: null };
+        }
+        // Calculate average duration (excluding entries without duration)
+        const durations = history
+            .map(entry => entry.durationMs)
+            .filter((d) => d !== undefined);
+        const avgDurationMs = durations.length > 0
+            ? durations.reduce((sum, d) => sum + d, 0) / durations.length
+            : null;
+        return { switchCount, avgDurationMs };
+    }
+    /**
+     * Force flush to disk (for graceful shutdown)
+     */
+    shutdown() {
+        if (this.pendingWrite) {
+            clearTimeout(this.pendingWrite);
+            this.pendingWrite = null;
+        }
+        this.flushToDisk();
+    }
+}
+exports.ModelHistoryManager = ModelHistoryManager;

package/dist/main/session-manager.js

@@ -12,6 +12,7 @@ class SessionManager {
         this.activeSessionId = null;
         this.emitter = null;
         this.sessionEndCallbacks = [];
+        this.modelHistoryManager = null;
         this.historyManager = historyManager;
         this.sessionPool = sessionPool;
     }
@@ -32,6 +33,9 @@ class SessionManager {
     setMainWindow(window) {
         this.emitter = new ipc_emitter_1.IPCEmitter(window);
     }
+    setModelHistoryManager(manager) {
+        this.modelHistoryManager = manager;
+    }
     initialize() {
         // Load persisted sessions
         const state = (0, session_persistence_1.loadSessionState)();
@@ -80,6 +84,7 @@ class SessionManager {
         if (!(0, session_persistence_1.validateDirectory)(workingDir)) {
             throw new Error('Invalid working directory');
         }
+        const model = request.model;
         const id = (0, uuid_1.v4)();
         const metadata = {
             id,
@@ -89,6 +94,55 @@ class SessionManager {
             status: 'starting',
             createdAt: Date.now(),
         };
+        // Register all callbacks on a CLIManager BEFORE any async operations
+        // that produce PTY output (fixes race where Phase 1 fires before callback is set)
+        const registerCallbacks = (mgr) => {
+            mgr.onModelChange((model) => {
+                const session = this.sessions.get(id);
+                if (session) {
+                    const previousModel = session.metadata.currentModel ?? null;
+                    session.metadata.currentModel = model;
+                    const event = {
+                        sessionId: id,
+                        model,
+                        previousModel,
+                        detectedAt: Date.now(),
+                    };
+                    // Emit model change event
+                    this.emitter?.emit('onModelChanged', event);
+                    // Log to model history
+                    if (this.modelHistoryManager) {
+                        this.modelHistoryManager.logSwitch(event);
+                    }
+                    // Also emit general session updated
+                    this.emitter?.emit('onSessionUpdated', session.metadata);
+                    this.persistState();
+                }
+            });
+            mgr.onOutput((data) => {
+                const output = { sessionId: id, data };
+                this.emitter?.emit('onSessionOutput', output);
+                // Record to history (async, non-blocking)
+                this.historyManager.recordOutput(id, data).catch(err => {
+                    console.error('Failed to record history:', err);
+                });
+            });
+            mgr.onExit((exitCode) => {
+                const session = this.sessions.get(id);
+                if (session) {
+                    session.metadata.status = 'exited';
+                    session.metadata.exitCode = exitCode;
+                    this.emitter?.emit('onSessionUpdated', session.metadata);
+                    this.emitter?.emit('onSessionExited', { sessionId: id, exitCode });
+                    this.persistState();
+                    this.notifySessionEnd(id);
+                    // Flush final history buffer
+                    this.historyManager.onSessionExit(id, exitCode).catch(err => {
+                        console.error('Failed to finalize session history:', err);
+                    });
+                }
+            });
+        };
         // Try to claim from pool first
         const pooledSession = this.sessionPool.claim();
         let cliManager;
@@ -96,8 +150,9 @@ class SessionManager {
             // POOL PATH: Activate pooled session
             console.log(`[SessionManager] Using pooled session ${pooledSession.id} for ${id}`);
             cliManager = pooledSession.cliManager;
+            registerCallbacks(cliManager);
             try {
-                await cliManager.initializeSession(workingDir, request.permissionMode);
+                await cliManager.initializeSession(workingDir, request.permissionMode, model);
             }
             catch (err) {
                 // Activation failed, fall back to direct creation
@@ -106,7 +161,9 @@ class SessionManager {
                 cliManager = new cli_manager_1.CLIManager({
                     workingDirectory: workingDir,
                     permissionMode: request.permissionMode,
+                    model,
                 });
+                registerCallbacks(cliManager);
                 await cliManager.spawn();
             }
         }
@@ -116,34 +173,11 @@ class SessionManager {
             cliManager = new cli_manager_1.CLIManager({
                 workingDirectory: workingDir,
                 permissionMode: request.permissionMode,
+                model,
             });
+            registerCallbacks(cliManager);
             cliManager.spawn();
         }
-        // Set up output handler
-        cliManager.onOutput((data) => {
-            const output = { sessionId: id, data };
-            this.emitter?.emit('onSessionOutput', output);
-            // Record to history (async, non-blocking)
-            this.historyManager.recordOutput(id, data).catch(err => {
-                console.error('Failed to record history:', err);
-            });
-        });
-        // Set up exit handler
-        cliManager.onExit((exitCode) => {
-            const session = this.sessions.get(id);
-            if (session) {
-                session.metadata.status = 'exited';
-                session.metadata.exitCode = exitCode;
-                this.emitter?.emit('onSessionUpdated', session.metadata);
-                this.emitter?.emit('onSessionExited', { sessionId: id, exitCode });
-                this.persistState();
-                this.notifySessionEnd(id);
-                // Flush final history buffer
-                this.historyManager.onSessionExit(id, exitCode).catch(err => {
-                    console.error('Failed to finalize session history:', err);
-                });
-            }
-        });
         // Update history metadata with session details
         this.historyManager.updateSessionMetadata(id, metadata.name, workingDir);
         // Store session
@@ -231,6 +265,28 @@ class SessionManager {
             permissionMode: session.metadata.permissionMode,
         });
         // Set up handlers
+        cliManager.onModelChange((model) => {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                const previousModel = session.metadata.currentModel ?? null;
+                session.metadata.currentModel = model;
+                const event = {
+                    sessionId,
+                    model,
+                    previousModel,
+                    detectedAt: Date.now(),
+                };
+                // Emit model change event
+                this.emitter?.emit('onModelChanged', event);
+                // Log to model history
+                if (this.modelHistoryManager) {
+                    this.modelHistoryManager.logSwitch(event);
+                }
+                // Also emit general session updated
+                this.emitter?.emit('onSessionUpdated', session.metadata);
+                this.persistState();
+            }
+        });
         cliManager.onOutput((data) => {
             const output = { sessionId, data };
             this.emitter?.emit('onSessionOutput', output);
@@ -256,6 +312,7 @@ class SessionManager {
         session.cliManager = cliManager;
         session.metadata.status = 'starting';
         session.metadata.exitCode = undefined;
+        session.metadata.currentModel = undefined; // Clear stale model — Phase 1 will re-detect
         try {
             cliManager.spawn();
             session.metadata.status = 'running';

package/dist/main/session-persistence.js

@@ -82,6 +82,7 @@ function saveSessionState(sessions, activeSessionId) {
             status: session.status,
             createdAt: session.createdAt,
             exitCode: session.exitCode,
+            currentModel: session.currentModel,
         })),
         activeSessionId,
         lastModified: Date.now(),

package/dist/main/session-pool.js

@@ -19,7 +19,10 @@ class SessionPool {
         if (this.isInitialized || !this.config.enabled || this.config.size === 0) {
             return;
         }
-        console.log(`[SessionPool] Initializing pool with size ${this.config.size}`);
+        try {
+            console.log(`[SessionPool] Initializing pool with size ${this.config.size}`);
+        }
+        catch (err) { /* Ignore EPIPE */ }
         // Pre-spawn configured number of idle sessions
         const spawnPromises = [];
         for (let i = 0; i < this.config.size; i++) {
@@ -29,7 +32,12 @@ class SessionPool {
         this.isInitialized = true;
         // Start periodic cleanup of stale sessions
         this.startCleanupInterval();
-        console.log(`[SessionPool] Initialized with ${this.idleQueue.length} idle sessions`);
+        try {
+            console.log(`[SessionPool] Initialized with ${this.idleQueue.length} idle sessions`);
+        }
+        catch (err) {
+            // Ignore EPIPE errors from console.log
+        }
     }
     /**
      * Claim an idle session from the pool.
@@ -43,7 +51,12 @@ class SessionPool {
         if (!pooled) {
             return null;
         }
-        console.log(`[SessionPool] Claimed session ${pooled.id}, ${this.idleQueue.length} remaining`);
+        try {
+            console.log(`[SessionPool] Claimed session ${pooled.id}, ${this.idleQueue.length} remaining`);
+        }
+        catch (err) {
+            // Ignore EPIPE errors from console.log
+        }
         // Trigger async replenishment (non-blocking)
         this.replenishPool().catch(err => {
             console.error('[SessionPool] Failed to replenish pool:', err);
@@ -61,16 +74,25 @@ class SessionPool {
         console.log(`[SessionPool] Config updated:`, this.config);
         // If disabled, destroy all idle sessions
         if (!this.config.enabled && oldEnabled) {
-            console.log('[SessionPool] Disabled - destroying all idle sessions');
+            try {
+                console.log('[SessionPool] Disabled - destroying all idle sessions');
+            }
+            catch (err) { /* Ignore EPIPE */ }
             this.destroyAllIdle();
             this.stopCleanupInterval();
             return;
         }
         // If enabled but was disabled, initialize
         if (this.config.enabled && !oldEnabled) {
-            console.log('[SessionPool] Enabled - initializing pool');
+            try {
+                console.log('[SessionPool] Enabled - initializing pool');
+            }
+            catch (err) { /* Ignore EPIPE */ }
             this.initialize().catch(err => {
-                console.error('[SessionPool] Failed to initialize after enable:', err);
+                try {
+                    console.error('[SessionPool] Failed to initialize after enable:', err);
+                }
+                catch (e) { /* Ignore EPIPE */ }
             });
             return;
         }
@@ -78,10 +100,16 @@ class SessionPool {
         if (this.config.enabled && this.config.size > oldSize) {
             const diff = this.config.size - this.idleQueue.length;
             if (diff > 0) {
-                console.log(`[SessionPool] Size increased - spawning ${diff} idle sessions`);
+                try {
+                    console.log(`[SessionPool] Size increased - spawning ${diff} idle sessions`);
+                }
+                catch (err) { /* Ignore EPIPE */ }
                 for (let i = 0; i < diff; i++) {
                     this.createIdleSession().catch(err => {
-                        console.error('[SessionPool] Failed to spawn idle session:', err);
+                        try {
+                            console.error('[SessionPool] Failed to spawn idle session:', err);
+                        }
+                        catch (e) { /* Ignore EPIPE */ }
                     });
                 }
             }
@@ -90,7 +118,10 @@ class SessionPool {
         if (this.config.enabled && this.config.size < oldSize) {
             const excess = this.idleQueue.length - this.config.size;
             if (excess > 0) {
-                console.log(`[SessionPool] Size decreased - destroying ${excess} idle sessions`);
+                try {
+                    console.log(`[SessionPool] Size decreased - destroying ${excess} idle sessions`);
+                }
+                catch (err) { /* Ignore EPIPE */ }
                 for (let i = 0; i < excess; i++) {
                     const pooled = this.idleQueue.pop();
                     if (pooled) {

package/dist/main/settings-persistence.js

@@ -78,6 +78,8 @@ function getDefaultSettings() {
             excludePatterns: [],
             scanTimeoutMs: 30000,
         },
+        defaultModel: 'sonnet',
+        modelPreset: 'balanced',
     };
 }
 // Validate split view layout by removing invalid session references
@@ -89,24 +91,40 @@ function validateSplitViewLayout(layout, validSessionIds) {
             : null;
         return { ...layout, sessionId };
     }
-    // Branch: recursively validate children
-    return {
-        ...layout,
-        children: [
-            validateSplitViewLayout(layout.children[0], validSessionIds),
-            validateSplitViewLayout(layout.children[1], validSessionIds)
-        ]
-    };
+    if (layout.type === 'branch') {
+        // Branch: recursively validate children
+        return {
+            ...layout,
+            children: [
+                validateSplitViewLayout(layout.children[0], validSessionIds),
+                validateSplitViewLayout(layout.children[1], validSessionIds)
+            ]
+        };
+    }
+    if (layout.type === 'grid') {
+        // Grid: recursively validate all children
+        return {
+            ...layout,
+            children: layout.children.map(child => validateSplitViewLayout(child, validSessionIds))
+        };
+    }
+    return layout;
 }
 // Get all pane IDs from layout tree
 function getAllPaneIdsFromLayout(layout) {
     if (layout.type === 'leaf') {
         return [layout.paneId];
     }
-    return [
-        ...getAllPaneIdsFromLayout(layout.children[0]),
-        ...getAllPaneIdsFromLayout(layout.children[1])
-    ];
+    if (layout.type === 'branch') {
+        return [
+            ...getAllPaneIdsFromLayout(layout.children[0]),
+            ...getAllPaneIdsFromLayout(layout.children[1])
+        ];
+    }
+    if (layout.type === 'grid') {
+        return layout.children.flatMap(child => getAllPaneIdsFromLayout(child));
+    }
+    return [];
 }
 // Validate layout structure (ensure it's well-formed)
 function isValidLayoutStructure(layout) {
@@ -126,6 +144,27 @@ function isValidLayoutStructure(layout) {
             }
             return isValidLayoutStructure(layout.children[0]) && isValidLayoutStructure(layout.children[1]);
         }
+        if (layout.type === 'grid') {
+            if (typeof layout.id !== 'string' || layout.id.length === 0) {
+                return false;
+            }
+            if (layout.direction !== 'horizontal' && layout.direction !== 'vertical') {
+                return false;
+            }
+            if (!Array.isArray(layout.children) || layout.children.length === 0) {
+                return false;
+            }
+            if (!Array.isArray(layout.sizes) || layout.sizes.length !== layout.children.length) {
+                return false;
+            }
+            // Validate sizes sum to approximately 100
+            const sum = layout.sizes.reduce((a, b) => a + b, 0);
+            if (Math.abs(sum - 100) > 0.5) {
+                return false;
+            }
+            // Validate all children
+            return layout.children.every(child => isValidLayoutStructure(child));
+        }
         return false;
     }
     catch {
@@ -339,6 +378,22 @@ class SettingsManager {
         this.settings.autoLayoutTeams = enabled;
         saveSettings(this.settings);
     }
+    updateUIMode(mode) {
+        this.settings.uiMode = mode;
+        saveSettings(this.settings);
+    }
+    updateDefaultModel(model) {
+        this.settings.defaultModel = model;
+        saveSettings(this.settings);
+    }
+    updateLastUsedLayoutPreset(presetId) {
+        this.settings.lastUsedLayoutPresetId = presetId;
+        saveSettings(this.settings);
+    }
+    markAsLaunched() {
+        this.settings.hasLaunchedBefore = true;
+        saveSettings(this.settings);
+    }
     validateSplitViewState(validSessionIds) {
         if (!this.settings.splitViewState) {
             return;