Merge pull request #928 from web3dev1337/fix/workspace-restore-origin

fix: restore workspaces after cold restart

Author: web3dev1337

client/app.js

@@ -183,6 +183,34 @@ class ClaudeOrchestrator {
     return type === 'server' || /-server$/.test(sid);
   }
 
+  async maybePlanWorkspaceRecovery(workspaceId, { interactive = true } = {}) {
+    const targetWorkspaceId = String(workspaceId || '').trim();
+    const DashboardCtor = window.Dashboard || (typeof Dashboard !== 'undefined' ? Dashboard : null);
+    if (!this.dashboard && DashboardCtor) {
+      this.dashboard = new DashboardCtor(this);
+    }
+    if (!targetWorkspaceId || !this.dashboard?.planRecoveryForWorkspace) {
+      return null;
+    }
+
+    const pendingWorkspaceId = String(this.dashboard?.pendingRecovery?.workspaceId || '').trim();
+    if (pendingWorkspaceId && pendingWorkspaceId === targetWorkspaceId) {
+      return this.dashboard.pendingRecovery;
+    }
+
+    try {
+      const recoveryPlan = await this.dashboard.planRecoveryForWorkspace(targetWorkspaceId, { interactive });
+      if (recoveryPlan?.pending) {
+        this.dashboard.pendingRecovery = recoveryPlan.pending;
+        return recoveryPlan.pending;
+      }
+    } catch (error) {
+      console.warn('Failed to prepare workspace recovery plan', { workspaceId: targetWorkspaceId, error });
+    }
+
+    return null;
+  }
+
   isMainlineBranch(branch) {
     const raw = String(branch || '').trim().toLowerCase();
     if (!raw) return true;
@@ -1575,6 +1603,10 @@ class ClaudeOrchestrator {
           }
         }
 
+        if (active) {
+          await this.maybePlanWorkspaceRecovery(active.id, { interactive: true });
+        }
+
         // Update voice command context with workspace info
         this.updateVoiceContext();
         this.applySimpleModeConfig();
@@ -1642,6 +1674,7 @@ class ClaudeOrchestrator {
             // visibility state that was just restored from the tab (fix #786).
             this.lastSessionsWorkspaceId = nextWorkspace.id;
 
+            await this.maybePlanWorkspaceRecovery(nextWorkspace.id, { interactive: true });
             this.handleInitialSessions(sessions);
 
             // Update workspace switcher
@@ -1669,6 +1702,7 @@ class ClaudeOrchestrator {
             // Pre-fetch worktree-specific configs for all terminals
             await this.prefetchWorktreeConfigs(nextWorkspace, sessions);
 
+            await this.maybePlanWorkspaceRecovery(nextWorkspace.id, { interactive: true });
             // Rebuild with new workspace sessions
             // Terminals will now register to the correct tab via currentTabId
             this.handleInitialSessions(sessions);

client/dashboard.js

@@ -3795,52 +3795,12 @@ class Dashboard {
   async openWorkspace(workspaceId) {
     console.log('Opening workspace:', workspaceId);
 
-    // Get recovery settings
-    const recoverySettings = this.orchestrator.userSettings?.global?.sessionRecovery || {};
-    const recoveryEnabled = recoverySettings.enabled !== false;
-    const recoveryMode = recoverySettings.mode || 'ask';
-
-    // Check for recovery state first (if enabled)
-    if (recoveryEnabled) {
-      const recoveryInfo = await this.checkRecoveryState(workspaceId);
-      if (recoveryInfo && recoveryInfo.recoverableSessions > 0) {
-        // If the user previously dismissed this exact snapshot, don't nag again.
-        const savedAt = String(recoveryInfo.savedAt || '').trim();
-        const dismissKey = `orchestrator-recovery-dismissed:${workspaceId}`;
-        let dismissedSnapshot = false;
-        if (savedAt) {
-          try {
-            const dismissedAt = String(localStorage.getItem(dismissKey) || '').trim();
-            if (dismissedAt && dismissedAt === savedAt) {
-              console.log('Skipping recovery dialog - dismissed for this snapshot');
-              dismissedSnapshot = true;
-            } else {
-              // Clear stale dismiss markers when the snapshot changes.
-              if (dismissedAt) localStorage.removeItem(dismissKey);
-            }
-          } catch {
-            // ignore
-          }
-        }
-
-        if (dismissedSnapshot) {
-          // Do nothing: proceed to open workspace with no recovery.
-        } else if (recoveryMode === 'auto') {
-          // Auto-recover all sessions
-          this.pendingRecovery = { workspaceId, mode: 'all', sessions: recoveryInfo.sessions };
-          console.log('Auto-recovering all sessions');
-        } else if (recoveryMode === 'ask') {
-          // Show recovery dialog and wait for user choice
-          const shouldRecover = await this.showRecoveryDialog(workspaceId, recoveryInfo);
-          if (shouldRecover === 'cancel') {
-            return; // User cancelled
-          }
-          this.pendingRecovery = shouldRecover && typeof shouldRecover === 'object'
-            ? { workspaceId, ...shouldRecover }
-            : shouldRecover;
-        }
-        // If mode === 'skip', don't set pendingRecovery
-      }
+    const recoveryPlan = await this.planRecoveryForWorkspace(workspaceId, { interactive: true });
+    if (recoveryPlan?.action === 'cancel') {
+      return;
+    }
+    if (recoveryPlan?.pending) {
+      this.pendingRecovery = recoveryPlan.pending;
     }
 
     // Show loading state
@@ -3866,6 +3826,61 @@ class Dashboard {
     this.orchestrator.socket.emit('switch-workspace', { workspaceId });
   }
 
+  async planRecoveryForWorkspace(workspaceId, { interactive = true } = {}) {
+    const targetWorkspaceId = String(workspaceId || '').trim();
+    if (!targetWorkspaceId) {
+      return { action: 'skip', pending: null };
+    }
+
+    const recoverySettings = this.orchestrator.userSettings?.global?.sessionRecovery || {};
+    const recoveryEnabled = recoverySettings.enabled !== false;
+    const recoveryMode = recoverySettings.mode || 'ask';
+    if (!recoveryEnabled) {
+      return { action: 'skip', pending: null };
+    }
+
+    const recoveryInfo = await this.checkRecoveryState(targetWorkspaceId);
+    if (!(recoveryInfo && recoveryInfo.recoverableSessions > 0)) {
+      return { action: 'skip', pending: null };
+    }
+
+    const savedAt = String(recoveryInfo.savedAt || '').trim();
+    const dismissKey = `orchestrator-recovery-dismissed:${targetWorkspaceId}`;
+    if (savedAt) {
+      try {
+        const dismissedAt = String(localStorage.getItem(dismissKey) || '').trim();
+        if (dismissedAt && dismissedAt === savedAt) {
+          console.log('Skipping recovery dialog - dismissed for this snapshot');
+          return { action: 'dismissed', pending: null };
+        }
+        if (dismissedAt) localStorage.removeItem(dismissKey);
+      } catch {
+        // ignore
+      }
+    }
+
+    if (recoveryMode === 'auto') {
+      console.log('Auto-recovering all sessions');
+      return {
+        action: 'recover',
+        pending: { workspaceId: targetWorkspaceId, mode: 'all', sessions: recoveryInfo.sessions }
+      };
+    }
+
+    if (recoveryMode === 'ask' && interactive) {
+      const shouldRecover = await this.showRecoveryDialog(targetWorkspaceId, recoveryInfo);
+      if (shouldRecover === 'cancel') {
+        return { action: 'cancel', pending: null };
+      }
+      const pending = shouldRecover && typeof shouldRecover === 'object'
+        ? { workspaceId: targetWorkspaceId, ...shouldRecover }
+        : null;
+      return pending ? { action: 'recover', pending } : { action: 'skip', pending: null };
+    }
+
+    return { action: 'skip', pending: null };
+  }
+
   showCreateWorkspaceWizard(options = {}) {
     console.log('Opening workspace creation wizard...');
     if (!window.WorkspaceWizard) {

server/index.js

@@ -4536,6 +4536,13 @@ app.get('/api/recovery/:workspaceId', async (req, res) => {
       allowSessionIds: allowSessionIds.length ? allowSessionIds : null,
       pruneMissing: true
     });
+    const pendingRecoverySessions = Array.isArray(recoveryInfo?.sessions)
+      ? recoveryInfo.sessions.filter((entry) => {
+          const sessionId = String(entry?.sessionId || '').trim();
+          if (!sessionId) return false;
+          return !sessionManager.hasSessionHydrated(sessionId, { workspaceId });
+        })
+      : [];
 
     let configuredWorktreeCount = 0;
     if (workspace) {
@@ -4558,8 +4565,14 @@ app.get('/api/recovery/:workspaceId', async (req, res) => {
 
     res.json({
       ...recoveryInfo,
+      recoverableSessions: pendingRecoverySessions.length,
+      sessions: pendingRecoverySessions,
       configuredTerminalCount: allowSessionIds.length,
-      configuredWorktreeCount
+      configuredWorktreeCount,
+      recoveryAlreadyAppliedCount: Math.max(
+        0,
+        Number(recoveryInfo?.recoverableSessions || 0) - pendingRecoverySessions.length
+      )
     });
   } catch (error) {
     logger.error('Failed to get recovery info', { error: error.message });

server/sessionManager.js

@@ -75,6 +75,7 @@ class SessionManager extends EventEmitter {
     // Keep inactive workspaces' sessions alive (PTYs keep running), keyed by workspace id.
     // The active workspace is always `this.workspace`, and its sessions live in `this.sessions`.
     this.workspaceSessionMaps = new Map(); // workspaceId -> Map(sessionId -> session)
+    this.recoveryHydratedSessions = new Set(); // `${workspaceId}::${sessionId}` after the current server boot
     this.statusDetector = null; // Will be set later
     this.gitHelper = null; // Will be set later
     this.fileWatchers = new Map(); // Store file watchers for .git/HEAD files
@@ -106,6 +107,34 @@ class SessionManager extends EventEmitter {
     this.worktrees = [];
   }
 
+  getRecoveryHydrationKey(sessionId, { workspaceId = null, session = null } = {}) {
+    const sid = String(sessionId || '').trim();
+    if (!sid) return null;
+    const resolvedSession = session || this.getSessionById(sid, { workspaceId }) || null;
+    const ws = String(workspaceId || resolvedSession?.workspace || '').trim();
+    if (!ws) return null;
+    return `${ws}::${sid}`;
+  }
+
+  markSessionHydrated(sessionId, { workspaceId = null, session = null } = {}) {
+    const key = this.getRecoveryHydrationKey(sessionId, { workspaceId, session });
+    if (!key) return false;
+    this.recoveryHydratedSessions.add(key);
+    return true;
+  }
+
+  clearSessionHydrated(sessionId, { workspaceId = null, session = null } = {}) {
+    const key = this.getRecoveryHydrationKey(sessionId, { workspaceId, session });
+    if (!key) return false;
+    return this.recoveryHydratedSessions.delete(key);
+  }
+
+  hasSessionHydrated(sessionId, { workspaceId = null, session = null } = {}) {
+    const key = this.getRecoveryHydrationKey(sessionId, { workspaceId, session });
+    if (!key) return false;
+    return this.recoveryHydratedSessions.has(key);
+  }
+
   // Determine effective inactivity timeout per session (ms)
   getSessionTimeout(session) {
     if (!session) return this.sessionTimeout;
@@ -958,6 +987,7 @@ class SessionManager extends EventEmitter {
       // Add workspace ID to session
       session.workspace = this.workspace?.id || null;
       this.sessions.set(sessionId, session);
+      this.clearSessionHydrated(sessionId, { workspaceId: session.workspace, session });
 
       if (session.workspace) {
         sessionRecoveryService.updateSession(session.workspace, sessionId, {
@@ -1768,6 +1798,14 @@ class SessionManager extends EventEmitter {
       }
 
       const sanitizedInput = this.sanitizeInputData(data);
+      const hasMeaningfulInput = Array.from(sanitizedInput).some((char) => (
+        char === '\r' ||
+        char === '\n' ||
+        (char.length === 1 && char.charCodeAt(0) >= 32)
+      ));
+      if (hasMeaningfulInput) {
+        this.markSessionHydrated(sessionId, { workspaceId: session.workspace, session });
+      }
       for (const char of sanitizedInput) {
         if (char === '\r' || char === '\n') {
           const command = session.currentCommand.trim();
@@ -2510,6 +2548,7 @@ class SessionManager extends EventEmitter {
     if (!session) return;
 
     logger.info('Terminating session', { sessionId: sid, workspaceId: session.workspace || ws || null });
+    this.clearSessionHydrated(sid, { workspaceId: session.workspace || ws || null, session });
 
     // Clear the inactivity timer to prevent infinite loops
     if (session.inactivityTimer) {