auto-claude: 229-implement-account-aware-terminal-session-persisten

apps/frontend/src/main/claude-profile/session-utils.ts

@@ -6,7 +6,8 @@
  * and can be copied between profiles to enable session continuity after profile switches.
  */
 
-import { existsSync, mkdirSync, copyFileSync, cpSync, unlinkSync } from 'fs';
+import { existsSync } from 'fs';
+import { mkdir, copyFile, cp, unlink } from 'fs/promises';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { isNodeError } from '../utils/type-guards';
@@ -95,12 +96,12 @@ export interface SessionMigrationResult {
  * @param sessionId - The session UUID to migrate
  * @returns Migration result with success status and details
  */
-export function migrateSession(
+export async function migrateSession(
   sourceConfigDir: string,
   targetConfigDir: string,
   cwd: string,
   sessionId: string
-): SessionMigrationResult {
+): Promise<SessionMigrationResult> {
   const result: SessionMigrationResult = {
     success: false,
     sessionId,
@@ -118,13 +119,13 @@ export function migrateSession(
   try {
     // Ensure target directory exists (do this first, before any file operations)
     const targetParentDir = dirname(targetFile);
-    mkdirSync(targetParentDir, { recursive: true });
+    await mkdir(targetParentDir, { recursive: true });
     console.warn('[SessionUtils] Ensured target directory exists:', targetParentDir);
 
     // Attempt to copy the session .jsonl file
     // This will throw if source doesn't exist or target cannot be written
     try {
-      copyFileSync(sourceFile, targetFile);
+      await copyFile(sourceFile, targetFile);
       result.filesCopied++;
       console.warn('[SessionUtils] Copied session file:', sourceFile, '->', targetFile);
     } catch (copyError) {
@@ -153,7 +154,7 @@ export function migrateSession(
     // Attempt to copy the session directory (tool-results) if it exists
     // Use try-catch instead of existsSync to avoid TOCTOU race
     try {
-      cpSync(sourceDir, targetDir, { recursive: true });
+      await cp(sourceDir, targetDir, { recursive: true });
       result.filesCopied++;
       console.warn('[SessionUtils] Copied session directory:', sourceDir, '->', targetDir);
     } catch (dirCopyError) {
@@ -182,7 +183,7 @@ export function migrateSession(
     // Clean up partially migrated session file to enable retry
     // Use try-catch instead of existsSync to avoid TOCTOU race
     try {
-      unlinkSync(targetFile);
+      await unlink(targetFile);
       console.warn('[SessionUtils] Cleaned up partial migration file:', targetFile);
     } catch (cleanupError) {
       // If file doesn't exist during cleanup, that's fine

apps/frontend/src/main/ipc-handlers/terminal-handlers.ts

@@ -252,6 +252,8 @@ export function registerTerminalHandlers(
             id: string;
             sessionId?: string;
             sessionMigrated?: boolean;
+            isClaudeMode?: boolean;
+            dangerouslySkipPermissions?: boolean;
           }> = [];
 
           // Process each terminal
@@ -273,7 +275,7 @@ export function registerTerminalHandlers(
                 to: targetConfigDir
               });
 
-              const migrationResult = migrateSession(
+              const migrationResult = await migrateSession(
                 sourceConfigDir,
                 targetConfigDir,
                 terminal.cwd,
@@ -284,11 +286,19 @@ export function registerTerminalHandlers(
               debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Session migration result:', migrationResult);
             }
 
+            // Store YOLO mode flag server-side for migrated sessions
+            // (consumed by resumeClaudeAsync when the new terminal resumes)
+            if (sessionMigrated && terminal.claudeSessionId && terminal.dangerouslySkipPermissions) {
+              terminalManager.storeMigratedSessionFlag(terminal.claudeSessionId, terminal.dangerouslySkipPermissions);
+            }
+
             // All terminals need refresh (PTY env vars can't be updated)
             terminalsNeedingRefresh.push({
               id: terminal.id,
               sessionId: terminal.claudeSessionId,
-              sessionMigrated
+              sessionMigrated,
+              isClaudeMode: terminal.isClaudeMode,
+              dangerouslySkipPermissions: terminal.dangerouslySkipPermissions
             });
           }
 
@@ -613,9 +623,9 @@ export function registerTerminalHandlers(
 
   ipcMain.on(
     IPC_CHANNELS.TERMINAL_RESUME_CLAUDE,
-    (_, id: string, sessionId?: string) => {
+    (_, id: string, sessionId?: string, options?: { migratedSession?: boolean }) => {
       // Use async version to avoid blocking main process during CLI detection
-      terminalManager.resumeClaudeAsync(id, sessionId).catch((error) => {
+      terminalManager.resumeClaudeAsync(id, sessionId, options).catch((error) => {
         console.warn('[terminal-handlers] Failed to resume Claude:', error);
       });
     }

apps/frontend/src/main/terminal/claude-integration-handler.ts

@@ -1386,7 +1386,8 @@ export async function invokeClaudeAsync(
 export async function resumeClaudeAsync(
   terminal: TerminalProcess,
   sessionId: string | undefined,
-  getWindow: WindowGetter
+  getWindow: WindowGetter,
+  options?: { migratedSession?: boolean }
 ): Promise<void> {
   // Track terminal state for cleanup on error
   const wasClaudeMode = terminal.isClaudeMode;
@@ -1419,12 +1420,19 @@ export async function resumeClaudeAsync(
     // and we don't want stale IDs persisting through SessionHandler.persistSessionAsync().
     terminal.claudeSessionId = undefined;
 
-    // Deprecation warning for callers still passing sessionId
-    if (sessionId) {
+    // Deprecation warning for callers still passing sessionId (skip for migrated sessions)
+    if (sessionId && !options?.migratedSession) {
       console.warn('[ClaudeIntegration:resumeClaudeAsync] sessionId parameter is deprecated and ignored; using claude --continue instead');
     }
 
-    const command = `${pathPrefix}${escapedClaudeCmd} --continue`;
+    if (options?.migratedSession) {
+      debugLog('[ClaudeIntegration:resumeClaudeAsync] Post-swap resume for terminal:', terminal.id);
+    }
+
+    // Preserve YOLO mode flag from terminal's stored state
+    const extraFlags = terminal.dangerouslySkipPermissions ? YOLO_MODE_FLAG : '';
+
+    const command = `${pathPrefix}${escapedClaudeCmd} --continue${extraFlags}`;
 
     // Use PtyManager.writeToPty for safer write with error handling
     PtyManager.writeToPty(terminal, `${command}\r`);

apps/frontend/src/main/terminal/terminal-manager.ts

@@ -11,7 +11,7 @@ import type {
   TerminalProcess,
   WindowGetter,
   TerminalOperationResult,
-  TerminalProfileChangeInfo
+  TerminalProfileChangeInfo,
 } from './types';
 import * as PtyManager from './pty-manager';
 import * as SessionHandler from './session-handler';
@@ -26,6 +26,8 @@ export class TerminalManager {
   private saveTimer: NodeJS.Timeout | null = null;
   private lastNotifiedRateLimitReset: Map<string, string> = new Map();
   private eventCallbacks: TerminalEventHandler.EventHandlerCallbacks;
+  /** Server-side storage for YOLO mode flags during profile migration (sessionId → flag) */
+  private migratedSessionFlags: Map<string, boolean> = new Map();
 
   constructor(getWindow: WindowGetter) {
     this.getWindow = getWindow;
@@ -101,6 +103,12 @@ export class TerminalManager {
    * Destroy a terminal process
    */
   async destroy(id: string): Promise<TerminalOperationResult> {
+    // Clean up migrated session flags if this terminal has a pending migrated session
+    const terminal = this.terminals.get(id);
+    if (terminal?.claudeSessionId) {
+      this.migratedSessionFlags.delete(terminal.claudeSessionId);
+    }
+
     return TerminalLifecycle.destroyTerminal(
       id,
       this.terminals,
@@ -114,6 +122,7 @@ export class TerminalManager {
    * Kill all terminal processes
    */
   async killAll(): Promise<void> {
+    this.migratedSessionFlags.clear();
     this.saveTimer = await TerminalLifecycle.destroyAllTerminals(
       this.terminals,
       this.saveTimer
@@ -223,13 +232,32 @@ export class TerminalManager {
   /**
    * Resume Claude in a terminal asynchronously (non-blocking)
    */
-  async resumeClaudeAsync(id: string, sessionId?: string): Promise<void> {
+  async resumeClaudeAsync(id: string, sessionId?: string, options?: { migratedSession?: boolean }): Promise<void> {
     const terminal = this.terminals.get(id);
     if (!terminal) {
       return;
     }
 
-    await ClaudeIntegration.resumeClaudeAsync(terminal, sessionId, this.getWindow);
+    // For migrated sessions, restore YOLO mode from server-side storage
+    // (set during profile change in storeMigratedSessionFlag)
+    if (options?.migratedSession && sessionId) {
+      const storedFlag = this.migratedSessionFlags.get(sessionId);
+      if (storedFlag !== undefined) {
+        terminal.dangerouslySkipPermissions = storedFlag;
+        this.migratedSessionFlags.delete(sessionId);
+      }
+    }
+
+    await ClaudeIntegration.resumeClaudeAsync(terminal, sessionId, this.getWindow, options);
+  }
+
+  /**
+   * Store YOLO mode flag for a session being migrated during profile swap.
+   * Called from the profile change handler before the renderer recreates terminals.
+   * The flag is consumed by resumeClaudeAsync when the new terminal resumes.
+   */
+  storeMigratedSessionFlag(sessionId: string, dangerouslySkipPermissions: boolean): void {
+    this.migratedSessionFlags.set(sessionId, dangerouslySkipPermissions);
   }
 
   /**
@@ -387,7 +415,8 @@ export class TerminalManager {
         projectPath: terminal.projectPath,
         claudeSessionId: terminal.claudeSessionId,
         claudeProfileId: terminal.claudeProfileId,
-        isClaudeMode: terminal.isClaudeMode
+        isClaudeMode: terminal.isClaudeMode,
+        dangerouslySkipPermissions: terminal.dangerouslySkipPermissions
       });
     }
 

apps/frontend/src/main/terminal/types.ts

@@ -99,4 +99,5 @@ export interface TerminalProfileChangeInfo {
   claudeSessionId?: string;
   claudeProfileId?: string;
   isClaudeMode: boolean;
+  dangerouslySkipPermissions?: boolean;
 }

apps/frontend/src/preload/api/terminal-api.ts

@@ -47,7 +47,7 @@ export interface TerminalAPI {
     rows?: number
   ) => Promise<IPCResult<import('../../shared/types').TerminalRestoreResult>>;
   clearTerminalSessions: (projectPath: string) => Promise<IPCResult>;
-  resumeClaudeInTerminal: (id: string, sessionId?: string) => void;
+  resumeClaudeInTerminal: (id: string, sessionId?: string, options?: { migratedSession?: boolean }) => void;
   activateDeferredClaudeResume: (id: string) => void;
   getTerminalSessionDates: (projectPath?: string) => Promise<IPCResult<import('../../shared/types').SessionDateInfo[]>>;
   getTerminalSessionsForDate: (
@@ -166,8 +166,8 @@ export const createTerminalAPI = (): TerminalAPI => ({
   clearTerminalSessions: (projectPath: string): Promise<IPCResult> =>
     ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_CLEAR_SESSIONS, projectPath),
 
-  resumeClaudeInTerminal: (id: string, sessionId?: string): void =>
-    ipcRenderer.send(IPC_CHANNELS.TERMINAL_RESUME_CLAUDE, id, sessionId),
+  resumeClaudeInTerminal: (id: string, sessionId?: string, options?: { migratedSession?: boolean }): void =>
+    ipcRenderer.send(IPC_CHANNELS.TERMINAL_RESUME_CLAUDE, id, sessionId, options),
 
   activateDeferredClaudeResume: (id: string): void =>
     ipcRenderer.send(IPC_CHANNELS.TERMINAL_ACTIVATE_DEFERRED_RESUME, id),

apps/frontend/src/renderer/hooks/useTerminalProfileChange.ts

@@ -8,7 +8,7 @@ import { debugLog, debugError } from '../../shared/utils/debug-logger';
  * Hook to handle terminal profile change events.
  * When a Claude profile switches, all terminals need to be recreated with the new profile's
  * environment variables. Terminals with active Claude sessions will have their sessions
- * migrated and can be resumed with --resume {sessionId}.
+ * migrated and automatically resumed with --continue.
  */
 export function useTerminalProfileChange(): void {
   // Track terminals being recreated to prevent duplicate processing
@@ -101,19 +101,25 @@ export function useTerminalProfileChange(): void {
         newId: newTerminal.id
       });
 
-      // If there was an active Claude session that was migrated, show a message
-      // and set up for potential resume
+      // If there was an active Claude session that was migrated, auto-resume it
       if (sessionId && sessionMigrated) {
-        debugLog('[useTerminalProfileChange] Session migrated, ready for resume:', sessionId);
-        // Store the session ID so the user can resume if desired
+        debugLog('[useTerminalProfileChange] Session migrated, auto-resuming:', sessionId);
+        // Store the session ID for tracking
         store.setClaudeSessionId(newTerminal.id, sessionId);
-        // Set pending resume flag - user can trigger resume from terminal tab
-        store.setPendingClaudeResume(newTerminal.id, true);
-        // Send a message to the terminal about the session
-        window.electronAPI.sendTerminalInput(
+
+        // Auto-resume the Claude session with --continue
+        // YOLO mode (dangerouslySkipPermissions) is preserved server-side by the
+        // main process during migration (storeMigratedSessionFlag), so resumeClaudeAsync
+        // will restore it automatically when migratedSession is true
+        // Note: resumeClaudeInTerminal uses fire-and-forget IPC (ipcRenderer.send),
+        // so errors in the main process cannot be caught here. The main process will
+        // emit onTerminalPendingResume if the resume fails, triggering deferred resume.
+        window.electronAPI.resumeClaudeInTerminal(
           newTerminal.id,
-          `# Profile switched. Previous Claude session available.\n# Run: claude --resume ${sessionId}\n`
+          sessionId,
+          { migratedSession: true }
         );
+        debugLog('[useTerminalProfileChange] Resume initiated for terminal:', newTerminal.id);
       }
 
     } finally {