ClaudeCodeControl.Cleanup.cs

/* *******************************************************************************************************************
 * Application: ClaudeCodeExtension
 *
 * Autor:  Daniel Carvalho Liedke
 *
 * Copyright © Daniel Carvalho Liedke 2026
 * Usage and reproduction in any manner whatsoever without the written permission of Daniel Carvalho Liedke is strictly forbidden.
 *
 * Purpose: Resource cleanup and temporary file management
 *
 * *******************************************************************************************************************/

using System;
using System.IO;
using System.Diagnostics;
using System.Windows;
using Microsoft.VisualStudio.Shell;

namespace ClaudeCodeVS
{
    public partial class ClaudeCodeControl 
    { 
        #region Temporary Directory Fields

        /// <summary>
        /// Session-specific temporary directory for storing pasted images
        /// </summary>
        private string tempImageDirectory;

        #endregion

        #region Temporary Directory Initialization

        /// <summary>
        /// Initializes the temporary directory for storing pasted images
        /// Cleans up any existing ClaudeCodeVS temp directories first
        /// </summary>
        private void InitializeTempDirectory()
        {
            try
            {
                // Clear any existing ClaudeCodeVS temp directories
                CleanupClaudeCodeVSTempDirectories();

                // Create a session-level temp directory for storing pasted images before sending
                tempImageDirectory = Path.Combine(Path.GetTempPath(), "ClaudeCodeVS_Session", Guid.NewGuid().ToString());
                Directory.CreateDirectory(tempImageDirectory);
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"Error creating temp directory: {ex.Message}");
                // Fallback to a simpler path
                tempImageDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
                Directory.CreateDirectory(tempImageDirectory);
            }
        }

        /// <summary>
        /// Cleans up all ClaudeCodeVS temporary directories from previous sessions
        /// </summary>
        private void CleanupClaudeCodeVSTempDirectories()
        {
            try
            {
                string tempPath = Path.GetTempPath();

                // Clean up old ClaudeCodeVS directories
                string claudeCodeVSPath = Path.Combine(tempPath, "ClaudeCodeVS");
                if (Directory.Exists(claudeCodeVSPath))
                {
                    Directory.Delete(claudeCodeVSPath, true);
                }

                // Clean up session directories
                string sessionPath = Path.Combine(tempPath, "ClaudeCodeVS_Session");
                if (Directory.Exists(sessionPath))
                {
                    Directory.Delete(sessionPath, true);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"Error cleaning up ClaudeCodeVS temp directories: {ex.Message}");
                // Continue even if cleanup fails
            }
        }

        #endregion

        #region Unload and Cleanup

        /// <summary>
        /// Handles control unload event - keeps terminal alive for tab switches
        /// </summary>
        private void ClaudeCodeControl_Unloaded(object sender, RoutedEventArgs e)
        {
            // Don't save during unload - settings should only be saved when user makes changes
            // NOTE: Don't cleanup terminal here - Unloaded fires during tab switches
            // Terminal cleanup only happens in Dispose() when VS is actually closing
        }

        /// <summary>
        /// Cleans up all resources including processes and temporary files
        /// </summary>
        private void CleanupResources()
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            try
            {
                // Cleanup diff tracking
                CleanupDiffTracking();

                // Unsubscribe from theme change events
                CleanupThemeEvents();

                // Kill child processes (like claude.exe) before killing the main cmd process
                if (cmdProcess != null && !cmdProcess.HasExited)
                {
                    try
                    {
                        KillProcessAndChildren(cmdProcess.Id);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"Error killing child processes: {ex.Message}");
                    }
                }

                // Kill and dispose terminal process
                if (cmdProcess != null && !cmdProcess.HasExited)
                {
                    try
                    {
                        cmdProcess.Kill();
                        cmdProcess.Dispose();
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"Error disposing cmd process: {ex.Message}");
                    }
                    cmdProcess = null;
                }

                // Clean up temporary directory
                if (Directory.Exists(tempImageDirectory))
                {
                    try
                    {
                        Directory.Delete(tempImageDirectory, true);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"Error cleaning temp directory: {ex.Message}");
                        // Try to at least delete files if directory deletion fails
                        try
                        {
                            foreach (string file in Directory.GetFiles(tempImageDirectory))
                            {
                                File.Delete(file);
                            }
                        }
                        catch { }
                    }
                }

                // Clear attached images list
                attachedImagePaths?.Clear();
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"Error during cleanup: {ex.Message}");
            }
        }

        /// <summary>
        /// Kills a process and all its child processes
        /// </summary>
        /// <param name="processId">The process ID to kill</param>
        private void KillProcessAndChildren(int processId)
        {
            try
            {
                // Use WMI to find and kill child processes
                using (var searcher = new System.Management.ManagementObjectSearcher(
                    $"SELECT ProcessId FROM Win32_Process WHERE ParentProcessId={processId}"))
                {
                    foreach (var obj in searcher.Get())
                    {
                        try
                        {
                            int childProcessId = Convert.ToInt32(obj["ProcessId"]);

                            // Recursively kill children of this child
                            KillProcessAndChildren(childProcessId);

                            // Kill the child process
                            var childProcess = Process.GetProcessById(childProcessId);
                            if (!childProcess.HasExited)
                            {
                                childProcess.Kill();
                                childProcess.Dispose();
                            }
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine($"Error killing child process: {ex.Message}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"Error in KillProcessAndChildren: {ex.Message}");
            }
        }

        /// <summary>
        /// Implements IDisposable - disposes of all managed resources
        /// </summary>
        public void Dispose()
        {
            ThreadHelper.ThrowIfNotOnUIThread();
            CleanupResources();
        }

        #endregion
    }
}