class.action.startup.php

Go to the documentation of this file.

<?php
/*
 *
 *  * Copyright (c) 2022-2025 Bearsampp
 *  * License: GNU General Public License version 3 or later; see LICENSE.txt
 *  * Website: https://bearsampp.com
 *  * Github: https://github.com/Bearsampp
 *
 */

class ActionStartup
{
    private $splash;
    private $restart;
    private $startTime;
    private $error;
 
    private $rootPath;
    private $filesToScan;
 
    const GAUGE_SERVICES = 5;
    const GAUGE_OTHERS = 19;

    public function __construct($args)
    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppLang, $bearsamppBins, $bearsamppWinbinder;
        $this->writeLog( 'Starting ' . APP_TITLE );
 
        // Init
        $this->splash    = new Splash();
        $this->restart   = false;
        $this->startTime = Util::getMicrotime();
        $this->error     = '';
 
        $this->rootPath    = $bearsamppRoot->getRootPath();
        $this->filesToScan = array();
 
        $gauge = self::GAUGE_SERVICES * count( $bearsamppBins->getServices() );
        $gauge += self::GAUGE_OTHERS + 1;
 
        // Start splash screen
        $this->splash->init(
            $bearsamppLang->getValue( Lang::STARTUP ),
            $gauge,
            sprintf( $bearsamppLang->getValue( Lang::STARTUP_STARTING_TEXT ), APP_TITLE . ' ' . $bearsamppCore->getAppVersion() )
        );
 
        $bearsamppWinbinder->setHandler( $this->splash->getWbWindow(), $this, 'processWindow', 1000 );
        $bearsamppWinbinder->mainLoop();
        $bearsamppWinbinder->reset();
    }

    public function processWindow($window, $id, $ctrl, $param1, $param2)
    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppLang, $bearsamppBins, $bearsamppTools, $bearsamppApps, $bearsamppWinbinder;
 
        Util::logTrace('Starting processWindow method');
 
        // Rotation logs
        Util::logTrace('Performing log rotation');
        $this->rotationLogs();
 
        // Clean
        Util::logTrace('Starting cleanup operations');
        $this->cleanTmpFolders();
        $this->cleanOldBehaviors();
 
        // List procs
        Util::logTrace('Listing running processes');
        if ($bearsamppRoot->getProcs() !== false) {
            $this->writeLog('List procs:');
            $listProcs = array();
            foreach ($bearsamppRoot->getProcs() as $proc) {
                $unixExePath = Util::formatUnixPath($proc[Win32Ps::EXECUTABLE_PATH]);
                $listProcs[] = '-> ' . basename($unixExePath) . ' (PID ' . $proc[Win32Ps::PROCESS_ID] . ') in ' . $unixExePath;
            }
            sort($listProcs);
            foreach ($listProcs as $proc) {
                $this->writeLog($proc);
            }
            Util::logTrace('Found ' . count($listProcs) . ' running processes');
        } else {
            Util::logTrace('No processes found or unable to retrieve process list');
        }
 
        // List modules
        Util::logTrace('Listing bins modules');
        $this->writeLog('List bins modules:');
        foreach ($bearsamppBins->getAll() as $module) {
            if (!$module->isEnable()) {
                $this->writeLog('-> ' . $module->getName() . ': ' . $bearsamppLang->getValue(Lang::DISABLED));
                Util::logTrace('Bin module ' . $module->getName() . ' is disabled');
            } else {
                $this->writeLog('-> ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
                Util::logTrace('Bin module ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
            }
        }
 
        Util::logTrace('Listing tools modules');
        $this->writeLog('List tools modules:');
        foreach ($bearsamppTools->getAll() as $module) {
            if (!$module->isEnable()) {
                $this->writeLog('-> ' . $module->getName() . ': ' . $bearsamppLang->getValue(Lang::DISABLED));
                Util::logTrace('Tool module ' . $module->getName() . ' is disabled');
            } else {
                $this->writeLog('-> ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
                Util::logTrace('Tool module ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
            }
        }
 
        Util::logTrace('Listing apps modules');
        $this->writeLog('List apps modules:');
        foreach ($bearsamppApps->getAll() as $module) {
            if (!$module->isEnable()) {
                $this->writeLog('-> ' . $module->getName() . ': ' . $bearsamppLang->getValue(Lang::DISABLED));
                Util::logTrace('App module ' . $module->getName() . ' is disabled');
            } else {
                $this->writeLog('-> ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
                Util::logTrace('App module ' . $module->getName() . ': ' . $module->getVersion() . ' (' . $module->getRelease() . ')');
            }
        }
 
        // Kill old instances
        Util::logTrace('Killing old instances');
        $this->killOldInstances();
 
        // Prepare app
        Util::logTrace('Preparing application - refreshing hostname');
        $this->refreshHostname();
 
        Util::logTrace('Checking launch startup settings');
        $this->checkLaunchStartup();
 
        Util::logTrace('Checking browser configuration');
        $this->checkBrowser();
 
        Util::logTrace('Gathering system information');
        $this->sysInfos();
 
        Util::logTrace('Refreshing aliases');
        $this->refreshAliases();
 
        Util::logTrace('Refreshing virtual hosts');
        $this->refreshVhosts();
 
        // Check app path
        Util::logTrace('Checking application path');
        $this->checkPath();
 
        Util::logTrace('Scanning folders');
        $this->scanFolders();
 
        Util::logTrace('Changing paths in files');
        $this->changePath();
 
        Util::logTrace('Saving current path');
        $this->savePath();
 
        // Check BEARSAMPP_PATH, BEARSAMPP_BINS and System Path reg keys
        Util::logTrace('Checking PATH registry key');
        $this->checkPathRegKey();
 
        Util::logTrace('Checking BINS registry key');
        $this->checkBinsRegKey();
 
        Util::logTrace('Checking System PATH registry key');
        $this->checkSystemPathRegKey();
 
        // Update config
        Util::logTrace('Updating configuration');
        $this->updateConfig();
 
        // Create SSL certificates
        Util::logTrace('Creating SSL certificates');
        $this->createSslCrts();
 
        // Install
        Util::logTrace('Installing services');
        $this->installServices();
 
        // Actions if everything OK
        if (!$this->restart && empty($this->error)) {
            Util::logTrace('Startup completed successfully - refreshing Git repositories');
            $this->refreshGitRepos();
            $startupTime = round(Util::getMicrotime() - $this->startTime, 3);
            $this->writeLog('Started in ' . $startupTime . 's');
            Util::logTrace('Application started successfully in ' . $startupTime . ' seconds');
        } else {
            Util::logTrace('Startup issues detected - incrementing progress bar');
            $this->splash->incrProgressBar(2);
        }
 
        if ($this->restart) {
            Util::logTrace('Restart required - preparing to restart application');
            $this->writeLog(APP_TITLE . ' has to be restarted');
            $this->splash->setTextLoading(
                sprintf(
                    $bearsamppLang->getValue(Lang::STARTUP_PREPARE_RESTART_TEXT),
                    APP_TITLE . ' ' . $bearsamppCore->getAppVersion()
                )
            );
 
            Util::logTrace('Deleting all services before restart');
            foreach ($bearsamppBins->getServices() as $sName => $service) {
                Util::logTrace('Deleting service: ' . $sName);
                $service->delete();
            }
 
            Util::logTrace('Setting execution action to RESTART');
            $bearsamppCore->setExec(ActionExec::RESTART);
        }
 
        if (!empty($this->error)) {
            Util::logTrace('Errors occurred during startup: ' . $this->error);
            $this->writeLog('Error: ' . $this->error);
            $bearsamppWinbinder->messageBoxError($this->error, $bearsamppLang->getValue(Lang::STARTUP_ERROR_TITLE));
        }
 
        Util::logTrace('Starting loading screen');
        Util::startLoading();
 
        // Give the loading window time to initialize before we terminate this process
        Util::logTrace('Waiting for loading window to initialize');
        usleep(500000); // 500ms delay to allow loading window to start
 
        Util::logTrace('Loading process started');
 
        // Closing cli to finish startup
        Util::logTrace('Finishing startup process');
 
        // Safely reset WinBinder and destroy the splash window
        $bearsamppWinbinder->destroyWindow($window);
        $bearsamppWinbinder->reset();
 
        // Exit this startup process cleanly - the loading window will continue running
        Util::logTrace('Exiting startup process cleanly');
        exit(0);
 
    }

    private function rotationLogs()
    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppConfig, $bearsamppLang, $bearsamppBins;
 
        Util::logTrace("Starting log rotation process");
        $this->splash->setTextLoading($bearsamppLang->getValue(Lang::STARTUP_ROTATION_LOGS_TEXT));
        $this->splash->incrProgressBar();
 
        $archivesPath = $bearsamppRoot->getLogsPath() . '/archives';
        if (!is_dir($archivesPath)) {
            Util::logTrace("Creating archives directory: " . $archivesPath);
            mkdir($archivesPath, 0777, true);
            return;
        }
 
        $date = date('Y-m-d-His', time());
        $archiveLogsPath = $archivesPath . '/' . $date;
        $archiveScriptsPath = $archiveLogsPath . '/scripts';
 
        // Create archive folders
        Util::logTrace("Creating archive directories for current rotation");
        if (!is_dir($archiveLogsPath)) {
            Util::logTrace("Creating logs archive directory: " . $archiveLogsPath);
            mkdir($archiveLogsPath, 0777, true);
        } else {
            Util::logTrace("Logs archive directory already exists: " . $archiveLogsPath);
        }
 
        if (!is_dir($archiveScriptsPath)) {
            Util::logTrace("Creating scripts archive directory: " . $archiveScriptsPath);
            mkdir($archiveScriptsPath, 0777, true);
        } else {
            Util::logTrace("Scripts archive directory already exists: " . $archiveScriptsPath);
        }
 
        // Count archives
        Util::logTrace("Counting existing archives");
        $archives = array();
        $handle = @opendir($archivesPath);
        if (!$handle) {
            Util::logTrace("Failed to open archives directory: " . $archivesPath);
            return;
        }
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..') {
                continue;
            }
            $archives[] = $archivesPath . '/' . $file;
        }
        closedir($handle);
        sort($archives);
        Util::logTrace("Found " . count($archives) . " existing archives");
 
        // Remove old archives
        if (count($archives) > $bearsamppConfig->getMaxLogsArchives()) {
            $total = count($archives) - $bearsamppConfig->getMaxLogsArchives();
            Util::logTrace("Removing " . $total . " old archives");
            for ($i = 0; $i < $total; $i++) {
                Util::logTrace("Deleting old archive: " . $archives[$i]);
                Util::deleteFolder($archives[$i]);
            }
        }
 
        // Helper function to check if a file is locked
        $isFileLocked = function($filePath) {
            if (!file_exists($filePath)) {
                return false;
            }
 
            $handle = @fopen($filePath, 'r+');
            if ($handle === false) {
                Util::logTrace("File appears to be locked: " . $filePath);
                return true; // File is locked
            }
 
            fclose($handle);
            return false; // File is not locked
        };
 
        // Logs
        Util::logTrace("Archiving log files");
        $srcPath = $bearsamppRoot->getLogsPath();
        $handle = @opendir($srcPath);
        if (!$handle) {
            Util::logTrace("Failed to open logs directory: " . $srcPath);
            return;
        }
 
        $logsCopied = 0;
        $logsSkipped = 0;
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..' || is_dir($srcPath . '/' . $file)) {
                continue;
            }
 
            $sourceFile = $srcPath . '/' . $file;
            $destFile = $archiveLogsPath . '/' . $file;
 
            // Check if file is locked before attempting to copy
            if ($isFileLocked($sourceFile)) {
                Util::logTrace("Skipping locked log file: " . $file);
                $logsSkipped++;
                continue;
            }
 
            try {
                if (copy($sourceFile, $destFile)) {
                    $logsCopied++;
                    Util::logTrace("Archived log file: " . $file);
                } else {
                    $logsSkipped++;
                    Util::logTrace("Failed to copy log file: " . $file);
                }
            } catch (Exception $e) {
                $logsSkipped++;
                Util::logTrace("Exception copying log file " . $file . ": " . $e->getMessage());
            }
        }
        closedir($handle);
        Util::logTrace("Logs archived: " . $logsCopied . " copied, " . $logsSkipped . " skipped");
 
        // Scripts
        Util::logTrace("Archiving script files");
        $srcPath = $bearsamppCore->getTmpPath();
        $handle = @opendir($srcPath);
        if (!$handle) {
            Util::logTrace("Failed to open tmp directory: " . $srcPath);
            return;
        }
 
        $scriptsCopied = 0;
        $scriptsSkipped = 0;
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..' || is_dir($srcPath . '/' . $file)) {
                continue;
            }
 
            $sourceFile = $srcPath . '/' . $file;
            $destFile = $archiveScriptsPath . '/' . $file;
 
            // Check if file is locked before attempting to copy
            if ($isFileLocked($sourceFile)) {
                Util::logTrace("Skipping locked script file: " . $file);
                $scriptsSkipped++;
                continue;
            }
 
            try {
                if (copy($sourceFile, $destFile)) {
                    $scriptsCopied++;
                    Util::logTrace("Archived script file: " . $file);
                } else {
                    $scriptsSkipped++;
                    Util::logTrace("Failed to copy script file: " . $file);
                }
            } catch (Exception $e) {
                $scriptsSkipped++;
                Util::logTrace("Exception copying script file " . $file . ": " . $e->getMessage());
            }
        }
        closedir($handle);
        Util::logTrace("Scripts archived: " . $scriptsCopied . " copied, " . $scriptsSkipped . " skipped");
 
        // Purge logs - only delete files that aren't locked
        Util::logTrace("Purging log files");
        $logsPath = $bearsamppRoot->getLogsPath();
        $handle = @opendir($logsPath);
        if (!$handle) {
            Util::logTrace("Failed to open logs directory for purging: " . $logsPath);
            return;
        }
 
        $logsDeleted = 0;
        $logsPurgeSkipped = 0;
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..' || $file == 'archives' || $file == '.gitignore' || is_dir($logsPath . '/' . $file)) {
                continue;
            }
 
            $filePath = $logsPath . '/' . $file;
 
            // Check if file is locked before attempting to delete
            if ($isFileLocked($filePath)) {
                Util::logTrace("Skipping locked log file during purge: " . $file);
                $logsPurgeSkipped++;
                continue;
            }
 
            try {
                if (file_exists($filePath) && unlink($filePath)) {
                    $logsDeleted++;
                    Util::logTrace("Purged log file: " . $file);
                } else {
                    $logsPurgeSkipped++;
                    Util::logTrace("Failed to purge log file: " . $file);
                }
            } catch (Exception $e) {
                $logsPurgeSkipped++;
                Util::logTrace("Exception purging log file " . $file . ": " . $e->getMessage());
            }
        }
        closedir($handle);
        Util::logTrace("Logs purged: " . $logsDeleted . " deleted, " . $logsPurgeSkipped . " skipped");
 
        Util::logTrace("Log rotation completed");
    }

    private function cleanTmpFolders()
    {
        global $bearsamppRoot, $bearsamppLang, $bearsamppCore;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_CLEAN_TMP_TEXT ) );
        $this->splash->incrProgressBar();
 
        $this->writeLog( 'Clear tmp folders' );
        Util::clearFolder( $bearsamppRoot->getTmpPath(), array('cachegrind', 'composer', 'openssl', 'mailpit', 'xlight', 'npm-cache', 'pip', 'opcache', '.gitignore') );
        Util::clearFolder( $bearsamppCore->getTmpPath(), array('.gitignore') );
 
        // Ensure opcache directory exists for persistent file cache
        $opcachePath = $bearsamppRoot->getTmpPath() . DIRECTORY_SEPARATOR . 'opcache';
 
        if (!is_dir($opcachePath)) {
            $this->writeLog('Creating opcache directory: ' . $opcachePath);
            if (!@mkdir($opcachePath, 0755, true) && !is_dir($opcachePath)) {
                $this->writeLog('Failed to create opcache directory: ' . $opcachePath);
                return;
            }
        }
 
        if (!is_writable($opcachePath)) {
            $this->writeLog('Opcache directory is not writable: ' . $opcachePath);
        }
    }

    private function cleanOldBehaviors()
    {
        global $bearsamppLang, $bearsamppRegistry;
 
        $this->writeLog( 'Clean old behaviors' );
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_CLEAN_OLD_BEHAVIORS_TEXT ) );
        $this->splash->incrProgressBar();
 
        // App >= 1.0.13
        $bearsamppRegistry->deleteValue(
            Registry::HKEY_LOCAL_MACHINE,
            'SOFTWARE\Microsoft\Windows\CurrentVersion\Run',
            APP_TITLE
        );
    }

    private function killOldInstances()
    {
        global $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_KILL_OLD_PROCS_TEXT ) );
        $this->splash->incrProgressBar();
 
        // Stop services
        /*foreach ($bearsamppBins->getServices() as $sName => $service) {
            $serviceInfos = $service->infos();
            if ($serviceInfos === false) {
                continue;
            }
            $service->stop();
        }*/
 
        // Stop third party procs
        $procsKilled = Win32Ps::killBins();
        if ( !empty( $procsKilled ) ) {
            $this->writeLog( 'Procs killed:' );
            $procsKilledSort = array();
            foreach ( $procsKilled as $proc ) {
                $unixExePath       = Util::formatUnixPath( $proc[Win32Ps::EXECUTABLE_PATH] );
                $procsKilledSort[] = '-> ' . basename( $unixExePath ) . ' (PID ' . $proc[Win32Ps::PROCESS_ID] . ') in ' . $unixExePath;
            }
            sort( $procsKilledSort );
            foreach ( $procsKilledSort as $proc ) {
                $this->writeLog( $proc );
            }
        }
    }

    private function refreshHostname()
    {
        global $bearsamppConfig, $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_REFRESH_HOSTNAME_TEXT ) );
        $this->splash->incrProgressBar();
        $this->writeLog( 'Refresh hostname' );
 
        $bearsamppConfig->replace( Config::CFG_HOSTNAME, gethostname() );
    }

    private function checkLaunchStartup()
    {
        global $bearsamppConfig;
 
        $this->writeLog( 'Check launch startup' );
 
        if ( $bearsamppConfig->isLaunchStartup() ) {
            Util::enableLaunchStartup();
        }
        else {
            Util::disableLaunchStartup();
        }
    }

    private function checkBrowser()
    {
        global $bearsamppConfig, $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_CHECK_BROWSER_TEXT ) );
        $this->splash->incrProgressBar();
        $this->writeLog( 'Check browser' );
 
        $currentBrowser = $bearsamppConfig->getBrowser();
        if ( empty( $currentBrowser ) || !file_exists( $currentBrowser ) ) {
            $bearsamppConfig->replace( Config::CFG_BROWSER, Vbs::getDefaultBrowser() );
        }
    }

    private function sysInfos()
    {
        global $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_SYS_INFOS ) );
        $this->splash->incrProgressBar();
 
        $os = Batch::getOsInfo();
        $this->writeLog( sprintf( 'OS: %s', $os ) );
    }

    private function refreshAliases()
    {
        global $bearsamppConfig, $bearsamppLang, $bearsamppBins;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_REFRESH_ALIAS_TEXT ) );
        $this->splash->incrProgressBar();
        $this->writeLog( 'Refresh aliases' );
 
        $bearsamppBins->getApache()->refreshAlias( $bearsamppConfig->isOnline() );
    }

    private function refreshVhosts()
    {
        global $bearsamppConfig, $bearsamppLang, $bearsamppBins;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_REFRESH_VHOSTS_TEXT ) );
        $this->splash->incrProgressBar();
        $this->writeLog( 'Refresh vhosts' );
 
        $bearsamppBins->getApache()->refreshVhosts( $bearsamppConfig->isOnline() );
    }

    private function checkPath()
    {
        global $bearsamppCore, $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_CHECK_PATH_TEXT ) );
        $this->splash->incrProgressBar();
 
        $this->writeLog( 'Last path: ' . $bearsamppCore->getLastPathContent() );
    }

    private function scanFolders()
    {
        global $bearsamppCore, $bearsamppLang;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_SCAN_FOLDERS_TEXT ) );
        $this->splash->incrProgressBar();
 
        $lastPath = $bearsamppCore->getLastPathContent();
        $currentPath = $this->rootPath;
 
        // Performance optimization: Skip scan if path hasn't changed
        if ($lastPath === $currentPath) {
            Util::logDebug('Path unchanged, skipping file scan (performance optimization)');
            Util::logTrace('Last path: "' . $lastPath . '" matches current path: "' . $currentPath . '"');
            $this->filesToScan = [];
            $this->writeLog('Files to scan: 0 (path unchanged - scan skipped)');
 
            // Log performance benefit
            $this->writeLog('Performance: File scan skipped, saving 3-8 seconds');
            return;
        }
 
        // Path changed, perform full scan
        Util::logDebug('Path changed, performing full file scan');
        Util::logTrace('Last path: "' . $lastPath . '" differs from current path: "' . $currentPath . '"');
        $this->writeLog('Path changed detected - performing full scan');
 
        $scanStartTime = Util::getMicrotime();
        $this->filesToScan = Util::getFilesToScan();
        $scanDuration = round(Util::getMicrotime() - $scanStartTime, 3);
 
        $this->writeLog('Files to scan: ' . count($this->filesToScan) . ' (scanned in ' . $scanDuration . 's)');
    }

    private function changePath()
    {
        global $bearsamppLang;
 
        $this->splash->setTextLoading( sprintf( $bearsamppLang->getValue( Lang::STARTUP_CHANGE_PATH_TEXT ), $this->rootPath ) );
        $this->splash->incrProgressBar();
 
        $result = Util::changePath( $this->filesToScan, $this->rootPath );
        $this->writeLog( 'Nb files changed: ' . $result['countChangedFiles'] );
        $this->writeLog( 'Nb occurences changed: ' . $result['countChangedOcc'] );
    }

    private function savePath()
    {
        global $bearsamppCore;
 
        file_put_contents( $bearsamppCore->getLastPath(), $this->rootPath );
        $this->writeLog( 'Save current path: ' . $this->rootPath );
    }

    private function checkPathRegKey()
    {
        global $bearsamppRoot, $bearsamppLang, $bearsamppRegistry;
 
        $this->splash->setTextLoading( sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_TEXT ), Registry::APP_PATH_REG_ENTRY ) );
        $this->splash->incrProgressBar();
 
        $currentAppPathRegKey = Util::getAppPathRegKey();
        $genAppPathRegKey     = Util::formatWindowsPath( $bearsamppRoot->getRootPath() );
        $this->writeLog( 'Current app path reg key: ' . $currentAppPathRegKey );
        $this->writeLog( 'Gen app path reg key: ' . $genAppPathRegKey );
        if ( $currentAppPathRegKey != $genAppPathRegKey ) {
            if ( !Util::setAppPathRegKey( $genAppPathRegKey ) ) {
                if ( !empty( $this->error ) ) {
                    $this->error .= PHP_EOL . PHP_EOL;
                }
                $this->error .= sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_ERROR_TEXT ), Registry::APP_PATH_REG_ENTRY );
                $this->error .= PHP_EOL . $bearsamppRegistry->getLatestError();
            }
            else {
                $this->writeLog( 'Need restart: checkPathRegKey' );
                $this->restart = true;
            }
        }
    }

    private function checkBinsRegKey()
    {
        global $bearsamppLang, $bearsamppRegistry;
 
        $this->splash->setTextLoading( sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_TEXT ), Registry::APP_BINS_REG_ENTRY ) );
        $this->splash->incrProgressBar();
 
        $currentAppBinsRegKey = Util::getAppBinsRegKey();
        $genAppBinsRegKey     = Util::getAppBinsRegKey( false );
        $this->writeLog( 'Current app bins reg key: ' . $currentAppBinsRegKey );
        $this->writeLog( 'Gen app bins reg key: ' . $genAppBinsRegKey );
        if ( $currentAppBinsRegKey != $genAppBinsRegKey ) {
            if ( !Util::setAppBinsRegKey( $genAppBinsRegKey ) ) {
                if ( !empty( $this->error ) ) {
                    $this->error .= PHP_EOL . PHP_EOL;
                }
                $this->error .= sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_ERROR_TEXT ), Registry::APP_BINS_REG_ENTRY );
                $this->error .= PHP_EOL . $bearsamppRegistry->getLatestError();
            }
            else {
                $this->writeLog( 'Need restart: checkBinsRegKey' );
                $this->restart = true;
            }
        }
    }

    private function checkSystemPathRegKey()
    {
        global $bearsamppLang, $bearsamppRegistry;
 
        $this->splash->setTextLoading( sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_TEXT ), Registry::SYSPATH_REG_ENTRY ) );
        $this->splash->incrProgressBar();
 
        $currentSysPathRegKey = Util::getSysPathRegKey();
        $this->writeLog( 'Current system PATH: ' . $currentSysPathRegKey );
 
        $newSysPathRegKey = str_replace( '%' . Registry::APP_BINS_REG_ENTRY . '%;', '', $currentSysPathRegKey );
        $newSysPathRegKey = str_replace( '%' . Registry::APP_BINS_REG_ENTRY . '%', '', $newSysPathRegKey );
        $newSysPathRegKey = '%' . Registry::APP_BINS_REG_ENTRY . '%;' . $newSysPathRegKey;
        $this->writeLog( 'New system PATH: ' . $newSysPathRegKey );
 
        if ( $currentSysPathRegKey != $newSysPathRegKey ) {
            if ( !Util::setSysPathRegKey( $newSysPathRegKey ) ) {
                if ( !empty( $this->error ) ) {
                    $this->error .= PHP_EOL . PHP_EOL;
                }
                $this->error .= sprintf( $bearsamppLang->getValue( Lang::STARTUP_REGISTRY_ERROR_TEXT ), Registry::SYSPATH_REG_ENTRY );
                $this->error .= PHP_EOL . $bearsamppRegistry->getLatestError();
            }
            else {
                $this->writeLog( 'Need restart: checkSystemPathRegKey' );
                $this->restart = true;
            }
        }
        else {
            $this->writeLog( 'Refresh system PATH: ' . $currentSysPathRegKey );
            Util::setSysPathRegKey( str_replace( '%' . Registry::APP_BINS_REG_ENTRY . '%', '', $currentSysPathRegKey ) );
            Util::setSysPathRegKey( $currentSysPathRegKey );
        }
    }

    private function updateConfig()
    {
        global $bearsamppLang, $bearsamppBins, $bearsamppTools, $bearsamppApps;
 
        $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_UPDATE_CONFIG_TEXT ) );
        $this->splash->incrProgressBar();
        $this->writeLog( 'Update config' );
 
        $bearsamppBins->update();
        $bearsamppTools->update();
        $bearsamppApps->update();
    }

    private function createSslCrts()
    {
        global $bearsamppLang, $bearsamppOpenSsl;
 
        $this->splash->incrProgressBar();
        if ( !$bearsamppOpenSsl->existsCrt( 'localhost' ) ) {
            $this->splash->setTextLoading( sprintf( $bearsamppLang->getValue( Lang::STARTUP_GEN_SSL_CRT_TEXT ), 'localhost' ) );
            $bearsamppOpenSsl->createCrt( 'localhost' );
        }
    }

 
    private function installServices()
    {
        global $bearsamppLang, $bearsamppBins, $bearsamppRoot;
 
        Util::logTrace('Starting installServices method');
 
        if (!$this->restart) {
            Util::logTrace('Normal startup mode - processing services');
 
            // Service Installation
            $this->installServicesSequential($bearsamppBins, $bearsamppLang);
        } else {
            Util::logTrace('Restart mode - skipping service installation');
            $this->splash->incrProgressBar(self::GAUGE_SERVICES * count($bearsamppBins->getServices()));
        }
 
        Util::logTrace('Completed installServices method');
    }

    private function installServicesSequential($bearsamppBins, $bearsamppLang)
    {
        Util::logTrace('Starting sequential service installation');
        $installStartTime = Util::getMicrotime();
 
        // Step 1: Check and prepare all services
        $servicesToStart = [];
        $serviceErrors = [];
 
        $totalServiceCount = count($bearsamppBins->getServices());
        $currentServiceIndex = 0;
 
        foreach ($bearsamppBins->getServices() as $sName => $service) {
            $currentServiceIndex++;
 
            Util::logTrace('Preparing service: ' . $sName);
 
            // prepareService() increments 1 step
            $serviceInfo = $this->prepareService($sName, $service, $bearsamppBins, $bearsamppLang, $currentServiceIndex, $totalServiceCount);
 
            if ($serviceInfo['restart']) {
                $this->writeLog('Need restart: installService ' . $serviceInfo['bin']->getName());
                Util::logTrace('Restart required for service: ' . $serviceInfo['bin']->getName());
                $this->restart = true;
                // prepareService used 1 step, need 4 more to reach GAUGE_SERVICES (5 total)
                $this->splash->incrProgressBar(self::GAUGE_SERVICES - 1);
                continue;
            }
 
            if (!empty($serviceInfo['error'])) {
                $serviceErrors[$sName] = $serviceInfo;
                // prepareService used 1 step, need 4 more to reach GAUGE_SERVICES (5 total)
                $this->splash->incrProgressBar(self::GAUGE_SERVICES - 1);
                continue;
            }
 
            if ($serviceInfo['needsStart']) {
                $servicesToStart[$sName] = $serviceInfo;
            } else {
                // Service already running or doesn't need to start
                // prepareService used 1 step, need 4 more to reach GAUGE_SERVICES (5 total)
                $this->splash->incrProgressBar(self::GAUGE_SERVICES - 1);
            }
        }
 
        // Step 2: Start all services sequentially with progress updates
        if (!empty($servicesToStart)) {
            Util::logTrace('Starting ' . count($servicesToStart) . ' services sequentially');
 
            $serviceCount = 0;
            $totalServices = count($servicesToStart);
 
            foreach ($servicesToStart as $sName => $serviceInfo) {
                $serviceCount++;
                $name = $serviceInfo['name'];
                $service = $serviceInfo['service'];
 
                // Update splash before starting (1 step - 2nd of 5)
                $this->splash->setTextLoading('Starting ' . $name . ' (' . $serviceCount . '/' . $totalServices . ')');
                $this->splash->incrProgressBar();
 
                Util::logTrace('Starting service: ' . $sName);
                $serviceStartTime = Util::getMicrotime();
 
                // Start the service
                $success = $service->start();
 
                $duration = round(Util::getMicrotime() - $serviceStartTime, 3);
 
                if ($success) {
                    $this->writeLog($name . ' service started in ' . $duration . 's');
                    Util::logTrace('Service ' . $name . ' started successfully in ' . $duration . ' seconds');
 
                    // Update splash after successful start
                    $this->splash->setTextLoading($name . ' started successfully');
                } else {
                    $error = $service->getError();
                    if (empty($error)) {
                        $error = 'Failed to start service';
                    }
 
                    $serviceErrors[$sName] = $serviceInfo;
                    $serviceErrors[$sName]['error'] = $error;
                    Util::logTrace('Service ' . $name . ' failed to start: ' . $error);
 
                    // Run syntax check if available
                    if (!empty($serviceInfo['syntaxCheckCmd'])) {
                        try {
                            $cmdSyntaxCheck = $serviceInfo['bin']->getCmdLineOutput($serviceInfo['syntaxCheckCmd']);
                            if (!$cmdSyntaxCheck['syntaxOk']) {
                                $serviceErrors[$sName]['error'] .= PHP_EOL . 'Syntax error: ' . $cmdSyntaxCheck['content'];
                            }
                        } catch (\Exception $e) {
                            // Ignore syntax check errors
                        }
                    }
                }
 
                // Complete remaining steps: prepareService=1, pre-start=1, now add 3 more = 5 total
                $this->splash->incrProgressBar(self::GAUGE_SERVICES - 2);
            }
        }
 
        // Step 3: Report any errors
        foreach ($serviceErrors as $sName => $serviceInfo) {
            if (!empty($serviceInfo['error'])) {
                Util::logTrace('Service error occurred for ' . $sName . ': ' . $serviceInfo['error']);
                if (!empty($this->error)) {
                    $this->error .= PHP_EOL . PHP_EOL;
                }
                $this->error .= sprintf($bearsamppLang->getValue(Lang::STARTUP_SERVICE_ERROR), $serviceInfo['name']) . PHP_EOL . $serviceInfo['error'];
            }
        }
 
        $installDuration = round(Util::getMicrotime() - $installStartTime, 3);
        $this->writeLog('Service installation completed in ' . $installDuration . 's');
        Util::logTrace('Service installation completed in ' . $installDuration . ' seconds');
    }

    private function prepareService($sName, $service, $bearsamppBins, $bearsamppLang, $currentIndex = 0, $totalCount = 0)
    {
        $serviceInfo = [
            'sName' => $sName,
            'service' => $service,
            'bin' => null,
            'name' => '',
            'port' => 0,
            'syntaxCheckCmd' => null,
            'error' => '',
            'restart' => false,
            'needsStart' => false,
            'startTime' => Util::getMicrotime()
        ];
 
        // Identify service type and get bin
        $syntaxCheckCmd = null;
        $bin = null;
        $port = 0;
 
        if ($sName == BinMailpit::SERVICE_NAME) {
            $bin = $bearsamppBins->getMailpit();
            $port = $bearsamppBins->getMailpit()->getSmtpPort();
        } elseif ($sName == BinMemcached::SERVICE_NAME) {
            $bin = $bearsamppBins->getMemcached();
            $port = $bearsamppBins->getMemcached()->getPort();
        } elseif ($sName == BinApache::SERVICE_NAME) {
            $bin = $bearsamppBins->getApache();
            $port = $bearsamppBins->getApache()->getPort();
            $syntaxCheckCmd = BinApache::CMD_SYNTAX_CHECK;
        } elseif ($sName == BinMysql::SERVICE_NAME) {
            $bin = $bearsamppBins->getMysql();
            $port = $bearsamppBins->getMysql()->getPort();
            $syntaxCheckCmd = BinMysql::CMD_SYNTAX_CHECK;
 
            // Pre-initialize MySQL data if needed
            if (!file_exists($bin->getDataDir()) || count(glob($bin->getDataDir() . '/*')) === 0) {
                Util::logTrace('Pre-initializing MySQL data directory');
                $bin->initData();
            }
        } elseif ($sName == BinMariadb::SERVICE_NAME) {
            $bin = $bearsamppBins->getMariadb();
            $port = $bearsamppBins->getMariadb()->getPort();
            $syntaxCheckCmd = BinMariadb::CMD_SYNTAX_CHECK;
        } elseif ($sName == BinPostgresql::SERVICE_NAME) {
            $bin = $bearsamppBins->getPostgresql();
            $port = $bearsamppBins->getPostgresql()->getPort();
        } elseif ($sName == BinXlight::SERVICE_NAME) {
            $bin = $bearsamppBins->getXlight();
            $port = $bearsamppBins->getXlight()->getPort();
        }
 
        $name = $bin->getName() . ' ' . $bin->getVersion() . ' (' . $service->getName() . ')';
 
        $serviceInfo['bin'] = $bin;
        $serviceInfo['name'] = $name;
        $serviceInfo['port'] = $port;
        $serviceInfo['syntaxCheckCmd'] = $syntaxCheckCmd;
 
        // Update splash with current service being checked (1 step)
        if ($currentIndex > 0 && $totalCount > 0) {
            $this->splash->setTextLoading('Checking ' . $bin->getName() . ' service (' . $currentIndex . '/' . $totalCount . ')');
        }
        $this->splash->incrProgressBar();
 
        // Check if service is already installed
        $serviceAlreadyInstalled = false;
        $serviceToRemove = false;
 
        if ($sName == BinApache::SERVICE_NAME) {
            $serviceInfos = $this->checkApacheServiceWithTimeout($service);
        } else if ($sName == BinMysql::SERVICE_NAME) {
            $serviceInfos = $this->checkMySQLServiceWithTimeout($service, $bin);
            if ($serviceInfos === false && $service->isInstalled()) {
                Util::logTrace('MySQL service appears to be hanging, forcing restart');
                Win32Ps::killBins(['mysqld.exe']);
                $service->delete();
                $serviceToRemove = true;
            }
        } else {
            try {
                $serviceInfos = $service->infos();
            } catch (\Exception $e) {
                Util::logTrace("Exception during service check: " . $e->getMessage());
                $serviceInfos = false;
            } catch (\Throwable $e) {
                Util::logTrace("Throwable during service check: " . $e->getMessage());
                $serviceInfos = false;
            }
        }
 
        if ($serviceInfos !== false) {
            $serviceAlreadyInstalled = true;
            $this->writeLog($name . ' service already installed');
 
            // Check if service needs to be removed and reinstalled
            if ($sName == BinPostgresql::SERVICE_NAME) {
                $serviceGenPathName = trim(str_replace('"', '', $service->getBinPath()));
                $installedPathParts = explode(' ', $serviceInfos[Win32Service::VBS_PATH_NAME], 2);
                $serviceVbsPathName = trim(str_replace('"', '', $installedPathParts[0]));
            } else {
                $serviceGenPathName = trim(str_replace('"', '', $service->getBinPath() . ($service->getParams() ? ' ' . $service->getParams() : '')));
                $serviceVbsPathName = trim(str_replace('"', '', $serviceInfos[Win32Service::VBS_PATH_NAME]));
            }
 
            $normalizedGenPath = preg_replace('/\s+/', ' ', $serviceGenPathName);
            $normalizedVbsPath = preg_replace('/\s+/', ' ', $serviceVbsPathName);
 
            if ($normalizedGenPath !== $normalizedVbsPath && $serviceGenPathName != $serviceVbsPathName) {
                $serviceToRemove = true;
                $this->writeLog($name . ' service has to be removed');
            }
        }
 
        // Remove service if needed (no progress increment - part of check phase)
        if ($serviceToRemove) {
            if (!$service->delete()) {
                $serviceInfo['restart'] = true;
                return $serviceInfo;
            }
        }
 
        // Check port availability (no progress increment - part of check phase)
        $isPortInUse = Util::isPortInUse($port);
        if ($isPortInUse !== false) {
            // Port is in use - check if it's our service that's already running
            if ($service->isRunning()) {
                // Service is already running and owns the port - this is OK
                $this->writeLog($name . ' service already running on port ' . $port);
                Util::logTrace('Service ' . $name . ' already running - no need to start');
                $serviceInfo['needsStart'] = false;
                return $serviceInfo;
            }
 
            // Port is in use by something else - this is an error
            $serviceInfo['error'] = sprintf($bearsamppLang->getValue(Lang::STARTUP_SERVICE_PORT_ERROR), $port, $isPortInUse);
            return $serviceInfo;
        }
 
        // Install service if needed (no progress increment - part of check phase)
        if (!$serviceAlreadyInstalled || $serviceToRemove) {
            if (!$service->create()) {
                $serviceInfo['error'] = sprintf($bearsamppLang->getValue(Lang::STARTUP_SERVICE_CREATE_ERROR), $service->getError());
                return $serviceInfo;
            }
        }
 
        $serviceInfo['needsStart'] = true;
        return $serviceInfo;
    }

    private function refreshGitRepos()
    {
        global $bearsamppLang, $bearsamppTools;
 
        $this->splash->incrProgressBar();
        if ( $bearsamppTools->getGit()->isScanStartup() ) {
            $this->splash->setTextLoading( $bearsamppLang->getValue( Lang::STARTUP_REFRESH_GIT_REPOS_TEXT ) );
 
            $repos = $bearsamppTools->getGit()->findRepos( false );
            $this->writeLog( 'Update GIT repos: ' . count( $repos ) . ' found' );
        }
    }

    private function checkApacheServiceWithTimeout($service)
    {
        Util::logTrace('Starting specialized Apache service check with timeout protection');
 
        // Set a timeout for the Apache service check
        $serviceCheckStartTime = microtime(true);
        $serviceCheckTimeout = 10; // 10 seconds timeout
 
        try {
            // Use a non-blocking approach to check service
            $serviceInfos = false;
 
            // First try a quick check if the service exists in the list
            $serviceList = Win32Service::getServices();
            if (is_array($serviceList) && isset($serviceList[$service->getName()])) {
                Util::logTrace('Apache service found in service list, getting details');
 
                // Service exists, now try to get its details with timeout protection
                $startTime = microtime(true);
                $serviceInfos = $service->infos();
 
                // Check if we've exceeded our timeout
                if (microtime(true) - $serviceCheckStartTime > $serviceCheckTimeout) {
                    Util::logTrace("Apache service check timeout exceeded, assuming service needs reinstall");
                    return false;
                }
            } else {
                Util::logTrace('Apache service not found in service list');
                return false;
            }
 
            return $serviceInfos;
        } catch (\Exception $e) {
            Util::logTrace("Exception during Apache service check: " . $e->getMessage());
            return false;
        } catch (\Throwable $e) {
            Util::logTrace("Throwable during Apache service check: " . $e->getMessage());
            return false;
        }
    }

    private function checkMySQLServiceWithTimeout($service, $bin)
    {
        Util::logTrace('Starting specialized MySQL service check with timeout protection');
 
        // Set a timeout for the MySQL service check
        $serviceCheckStartTime = microtime(true);
        $serviceCheckTimeout = 8; // 8 seconds timeout
 
        try {
            // Use a non-blocking approach to check service
            $serviceInfos = false;
 
            // First check if the service exists in the list
            $serviceList = Win32Service::getServices();
            if (is_array($serviceList) && isset($serviceList[$service->getName()])) {
                Util::logTrace('MySQL service found in service list, getting details');
 
                // Service exists, now try to get its details with timeout protection
                $serviceInfos = $service->infos();
 
                // Check if we've exceeded our timeout
                if (microtime(true) - $serviceCheckStartTime > $serviceCheckTimeout) {
                    Util::logTrace("MySQL service check timeout exceeded, assuming service needs reinstall");
                    return false;
                }
            } else {
                Util::logTrace('MySQL service not found in service list');
                return false;
            }
 
            return $serviceInfos;
        } catch (\Exception $e) {
            Util::logTrace("Exception during MySQL service check: " . $e->getMessage());
            return false;
        } catch (\Throwable $e) {
            Util::logTrace("Throwable during MySQL service check: " . $e->getMessage());
            return false;
        }
    }

    private function writeLog($log)
    {
        global $bearsamppRoot;
        Util::logDebug( $log, $bearsamppRoot->getStartupLogFilePath() );
    }
}