nicoverbruggen/phpmon

PHP Monitor is a macOS menu bar application that manages local PHP development environments, primarily integrating with Laravel Valet and Homebrew. It provides capabilities for switching PHP versions, managing extensions, configuring Nginx, and monitoring service health, while also offering an onboarding wizard to automate initial setup. The system includes diagnostic tools like PHP Doctor to detect and fix configuration issues, alongside a command history tracker and customizable presets for environment state management.

46 changes.

The project underwent a comprehensive architectural rewrite to replace the legacy Storyboard-based interface with a code-first SwiftUI design, while migrating the entire codebase to Swift concurrency for thread safety. This period focused on eliminating main-thread deadlocks by refactoring shell execution, file I/O, and PHP version switching into asynchronous, non-blocking operations. Concurrently, the application expanded its feature set with granular menu controls, robust error handling, and extensive unit and UI test coverage to support the new modular structure.

28 changes.

This period focused on modernizing the application's user interface by migrating components to SwiftUI and introducing comprehensive localization for multiple languages. Concurrently, the backend was refactored to improve robustness, featuring a rewrite of Homebrew integration with Swift concurrency, enhanced error handling, and new diagnostic tools like PHP Doctor.

36 changes.

This period focused on replacing the legacy setup process with a comprehensive, declarative onboarding wizard that automates environment configuration and privileged command handling. Concurrently, the project significantly expanded internationalization support by adding full UI translations for multiple languages and introduced new features such as command history tracking and domain favorites.

A new BusyStatus class has been introduced in the Common/State module to manage application busy states. This model exposes published properties for busy status, title, and description, allowing the UI to display loading indicators or status messages to users. Static factory methods are provided to easily create not-busy and busy instances.

phpmon/Common/State · high confidence

A new Command History window has been added to the application, accessible via the menu, which displays a list of executed commands along with their status and duration. The view utilizes a dedicated window controller to present a scrollable list where active commands show a live-updating duration counter that only ticks while the row is visible on screen, optimizing performance. Completed commands display their final duration, and the list automatically scrolls to the bottom as new commands are recorded.

phpmon/Modules/Command History · high confidence

This change introduces a suite of new Swift extensions in the Common/Extensions module to support core application functionality. It adds helpers for formatting and comparing version strings, chunking arrays, and pretty-printing JSON data. For the user interface, it provides utilities for resizing images, centering and shaking windows, and constructing NSMenu items with system or custom icons. It also implements a robust localization system that respects user language preferences and includes a dedicated alert handler for displaying standardized error messages.

phpmon/Common/Extensions · high confidence

The phpmon-shared module now includes new Swift files providing core utility functions: a Measurement struct for tracking elapsed time in milliseconds, and system interaction helpers (system, system\_quiet, identity) for executing shell commands and retrieving the current user's username.

phpmon-shared · high confidence

PHP Monitor now includes localized user interface strings for Arabic (ar), Bengali (bn), and Hindi (hi), covering menus, configuration managers, version management, and domain list labels.

phpmon/ar.lproj, phpmon/bn.lproj, phpmon/hi.lproj · high confidence

A new Favorites module has been introduced to the Domain List, allowing users to mark specific domains as favorites. This functionality is implemented via a new Favorites class that persists the list of favorite domains using UserDefaults, enabling users to toggle domains in and out of their favorites list.

phpmon/Modules/Domain List · high confidence

PHP Monitor now includes a complete Indonesian translation for its user interface, covering menus, configuration editors, version management, domain lists, and onboarding flows.

phpmon/id.lproj · high confidence

PHP Monitor now includes an Internet Access Policy (IAP) configuration file to declare its network connections for macOS privacy transparency. This policy explicitly lists the domains the application contacts, including phpmon.app and api.phpmon.app for update checks and documentation, GitHub and the NPM registry via Homebrew for PHP formula information, and the Homebrew API for version detection. Users will see these declared purposes when the app first requests network permission, clarifying why connections to these hosts are necessary for features like version switching and update checking.

phpmon/IAP · high confidence

PHP Monitor now includes localized user interface strings for Italian and Turkish, covering menus, configuration editors, domain lists, and health warnings. Users with these languages set in their system preferences will see the application interface translated accordingly.

phpmon/it.lproj · high confidence

A new RCFile struct has been introduced in the common integration domain to parse .valetrc configuration files. This component reads the file contents, splits lines by newlines, and extracts key-value pairs separated by equals signs, while handling whitespace trimming and quote removal. This enables the application to correctly interpret .valetrc settings.

phpmon/Domain/Integrations/Common · high confidence

The application now includes a complete Simplified Chinese (zh-Hans) translation for its user interface, covering menu items, configuration editors, PHP version management dialogs, domain lists, and onboarding flows.

phpmon/zh-Hans.lproj · high confidence

Users can now see the application interface in Spanish. This change adds the \es.lproj/Localizable.strings\ file, providing translations for all UI elements including the main menu, PHP version manager, extension manager, domain list, configuration editor, and various health warnings and tooltips.

phpmon/es.lproj · high confidence

A new SwiftUIHelper.swift file has been introduced to provide runtime environment checks and color definitions. It adds nonisolated properties to detect whether the app is running in test mode or SwiftUI previews, and extends the Color type with app-specific primary and debug colors, including a yellow debug color triggered by an environment variable.

phpmon/Domain/SwiftUI/Common · high confidence

Users can now see the application interface in Vietnamese and German. This change adds the \vi.lproj\ and \de.lproj\ localization bundles, providing translated strings for the main menu, PHP version manager, extension manager, configuration editor, domain list, and onboarding flows.

phpmon/vi.lproj · high confidence

Introduced \TrackableTestableCommand\ and \TrackableTestableShell\ classes that wrap the existing testable execution components to record and monitor command activity. These new classes intercept synchronous and asynchronous shell operations (such as \sync\, \pipe\, and \attach\) as well as general command execution, using a \CommandTracker\ to log command descriptions and track their lifecycle from any thread. This enables visibility into which commands are being executed during testing scenarios without altering the underlying testable behavior.

phpmon/Common/Monitoring/Testable · high confidence

A new \GlobalKeybindPreference\ struct has been introduced to represent and manage global keyboard shortcuts within the application's preferences. This model handles the serialization of key combinations (including modifier keys like Command, Control, Option, Shift, and Function) into a human-readable format for display and persists the data to UserDefaults as JSON.

phpmon/Domain/Preferences/Keybinds · high confidence

The Valet site integration now validates TLS certificates and exposes security metadata for each site. A new CertificateValidator checks whether a site's certificate exists and extracts its expiration date, issue date, and common name. ValetSite models now track certificate expiry and whether the certificate has expired, and the site determination process reads certificate, Nginx isolation config, composer.json, and .valetrc/.valetphprc files in a background snapshot to avoid blocking the main thread. This enables the UI to display certificate information and warn users when certificates have expired.

phpmon/Domain/Integrations/Valet/Sites · high confidence

The application now records a history of executed commands, storing up to 200 entries with start and completion timestamps. This feature is implemented via new \CommandTracker\, \TrackedCommand\, and \TrackedShell\ components that wrap existing shell and command execution logic to automatically log activity, enabling users to view past command history and durations within the monitoring interface.

phpmon/Common/Monitoring · high confidence

The application now includes a complete set of English translations for its core management interfaces, including the PHP Version Manager, Extension Manager, and Configuration Editor. Users will see localized strings for menu items, status messages, installation and upgrade workflows, diagnostic alerts, and configuration descriptions, ensuring a consistent and understandable experience across all PHP management and Valet integration features.

phpmon/en.lproj · high confidence

The application now includes a complete French translation for its user interface, covering menu items, configuration editors, PHP version management, extension management, domain lists, and onboarding flows.

phpmon/fr.lproj · high confidence

This update adds the first complete Dutch (nl) translation for the application, covering the main menu, PHP version manager, extension manager, domain list, and configuration presets. Users can now interact with the app in Dutch, including specific UI elements like the 'Actions' menu, search placeholders, and health warning messages.

phpmon/nl.lproj · high confidence

Added new Swift types to represent Homebrew package metadata and service states, enabling the application to decode and display Homebrew-related information such as package versions, aliases, and service status (running, loaded, PID).

phpmon/Common/PHP/Homebrew · high confidence

The PHP Config Editor now includes a dedicated SwiftUI-based window that allows users to view and modify specific PHP configuration values, including memory\_limit, post\_max\_size, and upload\_max\_filesize. This new interface presents these byte-limit settings with editable text fields and unit pickers, supporting both fixed values and unlimited options, with automatic debounced saving to ensure changes are persisted without blocking the main thread.

phpmon/Modules/PHP Config Editor/UI · high confidence

The PHP Doctor module now features a dedicated window that displays environment warnings and provides one-click automatic fixes. Users can refresh the environment check, view detailed warning descriptions, and trigger async fix actions directly from the interface, with visual feedback (progress indicators) while fixes are running. A separate 'No Warnings' view is shown when the environment is healthy.

phpmon/Modules/PHP Doctor/UI · high confidence

The PHP Doctor module now includes a new data layer that actively checks the user's environment for common configuration issues and offers automatic fixes. This includes verifying the existence of critical PHP configuration files (php.ini, php-fpm.conf), detecting missing or untrusted Homebrew taps, identifying invalid shell paths, and checking for expired Valet certificates. Users will see specific warnings for these conditions, such as helper binaries not being in the PATH or Xdebug configuration missing the mode setting, with the ability to apply one-click fixes where available (e.g., adding the bin path to zsh, trusting taps, or configuring xdebug.mode).

phpmon/Modules/PHP Doctor/Data · high confidence

Adds the user interface for managing PHP extensions, including a searchable list view, a picker to select the target PHP version, and controls to install or remove extensions. The interface displays extension status (installed, external, or installable), shows dependency information, and provides confirmation dialogs before removal, along with error handling for busy states and command failures.

phpmon/Modules/PHP Extension Manager/UI · high confidence

Users can now create and apply named presets that switch PHP versions, enable or disable extensions, and modify configuration values. Each preset includes a built-in rollback mechanism: applying a preset automatically saves the previous state to a JSON file, allowing users to revert changes via the 'AutomaticRevertSnapshot' preset. The system provides clear in-app alerts describing what will change before application and sends local notifications upon successful application or reversal of a preset.

phpmon/Domain/Presets · high confidence

The HTTP layer in phpmon/Common/Http now includes a WebApiProtocol, a RealWebApi implementation, and a TestableWebApi stub. The real implementation adds a randomized 'X-phpmon-session-uuid' header to API requests for better tracking, while the new testable variant allows injecting fake responses and simulating network delays, enabling more reliable and deterministic testing of API interactions.

phpmon/Common/Http · high confidence

The application now includes a new Welcome Tour window that appears to guide users through key features. This tour highlights the menu bar integration and, when Valet is installed, provides access to services, domains, and isolation settings. The window also includes a hint to the FAQ and automatically triggers a background check for application updates upon its first closure.

phpmon/Modules/WelcomeScreen · high confidence

Added a new Japanese (ja.lproj) localization file containing 730 translated strings for the PHP Monitor application. This update provides Japanese translations for the main menu, PHP version manager, extension manager, configuration editor, domain list, and various system warnings and status messages, enabling Japanese-speaking users to interact with the application in their native language.

phpmon/ja.lproj · high confidence

The app now includes a dedicated MarkdownTextView component that renders simplified Markdown, specifically supporting inline code spans, bold, and italic text. Inline code is visually distinguished by a rounded background and monospaced font, and copying code spans preserves the backtick formatting while stripping internal layout characters.

phpmon/Domain/SwiftUI/Common/Markdown · high confidence

A new PhpGuard class has been introduced in the PHP domain to monitor the active PHP version. It compares the currently linked PHP version against the previously stored global version and, if they differ, displays an NVAlert dialog offering the user the option to switch back to the previous version or stay with the current one. The guard also handles cases where the version is unreadable by logging a warning and prevents the alert from appearing during tests or SwiftUI previews.

phpmon/Domain/PHP · high confidence

This change introduces a set of reusable SwiftUI components to the application's common UI library. It adds custom button styles (including a standard 'custom' style with press/disabled states), a HelpButton for contextual assistance, and a SimpleButton for icon-text actions. Additionally, it provides views for handling user feedback states: BlockingOverlayView for displaying loading indicators during busy operations, ErrorView for showing error messages, and UnavailableContentView for displaying empty or unavailable states with optional action buttons.

phpmon/Domain/SwiftUI/Common/Buttons, phpmon/Domain/SwiftUI/Common/Views · high confidence

Added a suite of helper scripts to streamline PHP Monitor development workflows. The new \scripts/translations/\ directory includes \find-missing.sh\ to report localization coverage gaps, \sync.py\ to backfill missing translations and remove stale keys from \Localizable.strings\ files based on a JSON payload, and \verify.sh\ to lint syntax. Additionally, \scripts/find-missing-xcode-files.py\ detects Swift files on disk that are not referenced in the Xcode project or build phases, and \scripts/generate-expired-valet-cert.sh\ creates expired Valet certificates for testing certificate-expiry warning flows.

scripts · high confidence

The startup flow now presents a dedicated alert window when an environment check fails, allowing users to attempt an automatic repair. This new UI includes a view to display the fix command, a terminal-style output area (using NSTextView) to show real-time shell execution, and a button row that adapts to the fix status (idle, running, completed, or failed). The underlying ViewModel manages the asynchronous fix execution, re-runs the check after the command completes, and handles outcomes such as continuing to the next check, retrying all checks, or quitting the app.

phpmon/Domain/SwiftUI/Startup · high confidence

The application now includes a new \NginxConfigurationFile\ class that parses Nginx \.conf\ files to extract the domain name, top-level domain, proxy address, and isolated PHP version. This enables the tool to read and interpret Nginx configuration data directly from disk, supporting features like identifying which PHP version is isolated for a specific domain or determining the backend proxy target.

phpmon/Domain/Integrations/Nginx · high confidence

The OnboardingStepRunner now orchestrates the full local environment setup for PHP development. It requests Apple Developer Tools installation and verifies completion, automatically updates the shell PATH (in .zshrc) for PHP Monitor, Composer, and Homebrew, and guides the user through installing Homebrew by copying the install command to the clipboard. It installs PHP and Composer via Homebrew, supporting conditional tap trust commands, and installs Laravel Valet with necessary temporary sudoers permissions, cleaning them up afterward. Each step provides streaming output and clear success/failure states.

phpmon/Modules/OnboardingWizard/Runner · high confidence

This change introduces a new Packagist integration module that enables the application to query the Packagist API for the latest stable version of PHP packages, specifically targeting Laravel Valet. The implementation includes a new \Packagist\ client that fetches version data via the v2 API with proper percent encoding, and a \ValetUpgrader\ component that reads the global Composer configuration to determine the current Valet constraint. It compares this against the latest available version and presents a user-facing alert offering an upgrade path, including options to proceed with the upgrade, cancel, or open the Composer folder if the version constraint does not match.

phpmon/Domain/Integrations/Packagist · high confidence

The application now includes a complete Portuguese (Portugal) translation for its user interface, covering all major features such as the PHP version manager, extension manager, domain list, configuration editor, and Laravel Valet integration.

phpmon/pt-PT.lproj · high confidence

The PHP Config Editor now allows users to modify PHP configuration entries that represent byte limits (such as memory\_limit), parsing values with units (KB, MB, GB) and persisting changes directly to the php.ini file. When a limit is updated, the application automatically reloads the main menu to reflect the new configuration values, ensuring the UI stays in sync with the underlying PHP settings.

phpmon/Modules/PHP Config Editor/Data · high confidence

The application now provides a dedicated menu for selecting Xdebug modes. A new Xdebug extension class reads the current 'xdebug.mode' configuration from the PHP environment and dynamically generates menu items for available modes (develop, coverage, debug, gcstats, profile, trace). Each menu item reflects the current state (on/off) and allows users to toggle the specific mode, with changes handled by the main menu's toggle action.

phpmon/Common/PHP/Extensions · high confidence

The file contents.xcworkspacedata, which previously defined the workspace reference to the phpmon.xcodeproj project, has been deleted. This change removes the explicit workspace configuration for the project.

phpmon.xcodeproj/project.xcworkspace · high confidence

The \phpmon.xcodeproj/project.pbxproj\ file has been deleted, removing the Xcode project configuration that previously defined the build settings, source files (such as \AppDelegate.swift\, \Shell.swift\, and \ViewController.swift\), and resource bundles for the phpmon application.

phpmon.xcodeproj · high confidence

The Xcode project has been restructured to support a modular architecture, introducing a dedicated 'PHP Monitor Self-Updater' target alongside the main app, unit tests, and UI tests. This change integrates the NVAppUpdater framework for update management and the CrashReporter framework for diagnostics, while organizing source code into synchronized root groups (phpmon, phpmon-shared, phpmon-updater) to streamline development and maintenance.

PHP Monitor.xcodeproj · high confidence

A change to existing behaviour in integrations — 1 commit, 1 file.

integrations · low confidence · unverified

A change to existing behaviour in assets/affinity — 13 commits, 4 files.

assets/affinity · medium confidence · unverified

The PHP version switcher now operates asynchronously using Swift concurrency, unlinking all existing versions and linking the new one in parallel to improve responsiveness. When Laravel Valet is installed, the switcher automatically ensures configuration validity by disabling the default \www.conf\ PHP-FPM pool file (renaming it to \.disabled-by-phpmon\) and generating necessary configuration files like \valet-fpm.conf\ and \error\_log.ini\ with correct user and path replacements. The switch also handles isolated site PHP versions and restarts nginx to apply changes.

phpmon/Common/PHP/Switcher · high confidence

PHP Monitor now automatically detects and fixes ownership issues in Homebrew's PHP installation directories (specifically /bin and /sbin folders) that can cause permission errors. When broken permissions are detected, the tool runs an administrative script to stop affected PHP services and recursively restore correct ownership to the user, ensuring smooth operation of PHP versions managed via Homebrew.

phpmon/Domain/Integrations/Homebrew/Behaviors · high confidence

When installing or removing PHP extensions, the application now automatically restarts the PHP-FPM service to ensure the changes take effect immediately. Additionally, removing an extension triggers cleanup logic that either deletes the extension's default configuration file or disables it if it resides in a non-default location, preventing stale configurations from persisting.

phpmon/Domain/Integrations/Homebrew/Commands/PHP Extensions · high confidence

The Composer integration now reads composer.json to determine PHP version constraints and identify notable dependencies, enabling detection of additional frameworks such as Tempest, Bedrock, CakePHP, Craft, Flarum, Jigsaw, Joomla, Katana, Kirby, OctoberCMS, Sculpin, Statamic, Zend, and Slim. The Composer window logic has been refactored to use the modern Swift Task API for asynchronous global updates, ensuring UI updates occur on the main thread and providing clearer success/failure feedback via local notifications and progress windows.

phpmon/Domain/Integrations/Composer · high confidence

The filesystem abstraction has been refactored to support Swift 6 concurrency by marking the \FileSystemProtocol\, \RealFileSystem\, and \TestableFileSystem\ as \nonisolated\ and \Sendable\. This ensures that synchronous, blocking file I/O operations are explicitly performed off the main actor, preventing UI hangs and main-thread blocking warnings. The \RealFileSystem\ implementation now explicitly depends on a \Container\ for path resolution (such as tilde expansion) and shell commands, while the \TestableFileSystem\ uses a serial access queue to guarantee thread-safe access to its internal state during tests.

phpmon/Common/Filesystem · high confidence

The Homebrew integration layer has been restructured to improve reliability and expand capabilities. A new automatic service detection system now identifies and manages common Homebrew services like PostgreSQL, MySQL, Redis, and Mailhog. The app also supports the \brew trust\ command, allowing it to automatically trust required PHP taps on compatible Homebrew installations. Under the hood, PHP version and extension management has been rewritten using new data models (BrewPhpFormula, BrewPhpExtension) and a dedicated handler, while Cask file parsing now utilizes a Web API for remote fetching. These changes provide a more robust foundation for managing PHP environments and Homebrew dependencies.

phpmon/Domain/Integrations/Homebrew · high confidence

The application now uses a new \ValetInteractor\ class to handle all interactions with Laravel Valet, such as linking, unlinking, proxying, securing, and isolating sites. This change introduces a dedicated interface (\ValetListable\) and a concrete implementation that executes the necessary shell commands, along with a \FakeValetInteractor\ to support testing and simulation of these operations without affecting the actual system.

phpmon/Domain/Integrations/Valet/Domains · high confidence

The application now uses a new \CommandProtocol\ to manage external command execution, providing a \RealCommand\ implementation for live subprocess handling and a \TestableCommand\ for controlled testing. This change ensures commands run safely off the main thread with proper Sendable conformance for Swift 6 concurrency, while also adding logic to detect and handle subprocess crashes (uncaught signals) and standard error output capture.

phpmon/Common/Command · high confidence

The Errors module now defines an AlertableError protocol to standardize how user-facing errors are identified for alert messages, alongside specific error types like AdminPrivilegeError (which maps to localized alert keys) and VersionParseError. These error structs are marked as nonisolated to ensure they can be safely thrown and compared across actor isolation boundaries without violating Swift concurrency rules.

phpmon/Common/Errors · high confidence

The onboarding experience is now driven by a declarative wizard flow that automatically detects and installs required tooling, including Apple Command Line Tools, Homebrew, PHP, Composer, and Valet. The wizard guides users through each step, automatically fixing the system PATH for zsh users and handling Valet sudoers configuration, while providing real-time terminal output and status banners to keep users informed during the setup process.

phpmon/Modules/OnboardingWizard/Data · high confidence

The application's menu bar and status item are now constructed programmatically via the new \AppMenu\, \MainMenu\, and \StatusMenu\ classes, replacing the previous \Main.storyboard\-based approach. This change introduces granular preference controls that allow users to toggle the visibility of specific menu sections, including the global PHP version switcher, services manager, Valet integration, PHP configuration finder, Composer toolkit, limits widget, extensions, presets, and miscellaneous first-aid items. The new structure also adds dedicated menu items for displaying the active driver (Valet or Standalone Mode) and supports dynamic UI updates based on the current PHP environment and user settings.

phpmon/Domain/Menu · high confidence

The application now loads user settings from a new custom configuration file at \~/.config/phpmon/config.json, automatically migrating any legacy \~/.phpmon.conf.json file to the new location. This change supports advanced customization via JSON keys for scan\_apps, presets, services, and environment variables (export). Additionally, the preferences system has been expanded to include granular UI controls, allowing users to toggle the visibility of specific menu bar items (such as the global version switcher, services manager, integrations, and presets) and manage notification behaviors for version changes, PHP-FPM restarts, and secure toggles.

phpmon/Domain/Preferences · high confidence

The application now features a redesigned onboarding wizard with a dedicated sidebar that displays a timeline of setup steps (such as Command Line Tools, Homebrew, PHP, and Valet) and their current status. The main content area dynamically switches between an introduction checklist and individual step details, which can include command blocks, progress indicators, and status banners. The wizard also introduces specific skip options for the Valet installation step and hides the main application menu during the process to focus the user's attention.

phpmon/Modules/OnboardingWizard/UI · high confidence

The project now includes dedicated Xcode schemes to support different build and testing workflows. A new 'PHP Monitor EAP' scheme is added for Early Access Program builds, featuring specific command-line arguments and environment variables like EXTREME\_DOCTOR\_MODE. A 'PHP Monitor Self-Updater' scheme is introduced to build and run the self-updater component separately. The main 'PHP Monitor' scheme has been updated to skip Unit Tests by default while enabling UI Tests, and a standalone 'Unit Tests' scheme is provided to run unit tests with the main thread checker disabled, allowing for more controlled test execution.

PHP Monitor.xcodeproj/xcshareddata · high confidence

The Common/Helpers module introduces several new components to improve user experience and stability. A centralized Alert helper now provides a consistent, main-thread-safe way to present modal confirmations. Application detection has been refactored into a dedicated class that scans for preset editors, IDEs, and terminals, with improved shell command handling to prevent crashes. To support macOS 13+, a LoginItemManager enables the app to manage its own startup login status. Concurrency and stability are enhanced via a RunBlocking utility for safe off-main-thread execution of synchronous tasks, a MainThreadGuard to catch UI-hanging bugs in debug builds, and a VersionExtractor for robust version string parsing.

phpmon/Common/Helpers · high confidence

Privileged commands now require explicit user approval via a new modal alert window (PrivilegedCommandAlertWindowController) featuring an approval/deny interface (PrivilegedCommandApprovalView). This change isolates privileged command execution in fake/test environments by introducing a DisabledPrivilegedCommandRunner that throws an error unless a test explicitly supplies an approval runner, preventing accidental execution of admin scripts during testing.

phpmon/Domain/PrivilegedCommand · high confidence

The Domains window now features a sidebar that lets you quickly filter the domain list by status and type, including Favorites, HTTP/HTTPS, Linked/Parked/Proxy, and Global/Isolated PHP versions. Each filter displays a live count of matching domains, and the list preserves your row selection when switching filters or performing actions like toggling favorites or securing sites. The sidebar layout is customizable (collapsible) and persists its state across app launches.

phpmon/Modules/Domain List/UI · high confidence

The application has been restructured to run without a storyboard, with the menu bar and main menu now built entirely in code. The app now supports an accessory (toolbar) mode that activates when no windows are open, and it includes a new self-updater with automatic crash reporting. A global hotkey system has been added to open the menu, and the app can now detect installed applications for domain source directories. URL scheme handling (phpmon://) has been reworked to prompt users for integration permissions. The startup sequence has been improved with better environment checks, and the app now supports Early Access Program (EAP) builds with distinct menu indicators.

phpmon/Domain/App · high confidence

The app now includes a dedicated Credits page (Credits.html) that thanks GitHub sponsors, lists localization contributors, and provides links to the privacy policy, FAQ, and social media channels. Additionally, the project has removed several legacy source files (AppDelegate, ImageGenerator, Shell, ViewController, and the Main storyboard) and cleaned up the Info.plist and entitlements, reflecting a shift away from the previous storyboard-based menu and manual status bar image generation.

phpmon · high confidence

The PHP Version Manager window now displays distinct visual status icons for each PHP formula—showing a blue arrow for available upgrades, a green checkmark for installed versions, and a dashed square for missing ones—along with a dedicated 'Upgrade All' button to update multiple versions at once. The interface also includes improved error handling that refreshes PHP health after failed operations and warns users about unsupported Homebrew versions or missing taps on launch.

phpmon/Modules/PHP Version Manager/UI · high confidence

The PHP Extension Manager now uses a new \BrewExtensionsObservable\ class to manage extension data. This change introduces asynchronous loading of available PHP extensions from the \shivammathur/homebrew-extensions\ Homebrew tap, ensuring that file operations and data fetching do not block the main UI thread. The observable automatically reloads extension data whenever the selected PHP version changes.

phpmon/Modules/PHP Extension Manager/Data · high confidence

The PHP Monitor helper generation logic has been refactored to correctly resolve Homebrew's \opt\ symlinks (e.g., \php@8.4\), ensuring that helper scripts point to the actual binary locations rather than broken or indirect paths. Additionally, the system now detects the user's shell (zsh, bash, or fish) to generate appropriate PATH-mutation scripts and includes a safeguard that prevents overwriting existing files in the helper directory that were not originally generated by PHP Monitor, protecting user customizations.

phpmon/Common/PHP/PHP Helper · high confidence

The domain list table cells have been completely rewritten to provide richer visual feedback and interaction. The Name cell now supports a favorite state, displaying a star icon for favorited sites. The PHP cell includes a button to switch PHP versions for isolated sites and an icon indicating whether a site is isolated or global. The TLS cell displays a lock icon that changes color based on certificate status (green for secure, red for insecure, orange for expired) and opens a popover with certificate details when clicked. The Type cell shows the detected driver (e.g., Laravel with version) and PHP version, with an info button that opens a popover for PHP version compatibility details and suggestions.

phpmon/Modules/Domain List/UI/Cells · high confidence

The domain creation workflow has been restructured into a multi-step process: users now first choose between creating a linked site or a proxy via SelectDomainTypeView, followed by dedicated AddSiteView and AddProxyView forms that include real-time validation and preview. Additionally, the VersionPopoverView has been updated to present PHP version suggestions, distinguishing between global switching and site-specific isolation based on user preferences, while SecurePopoverView now provides detailed certificate status and renewal options.

phpmon/Domain/SwiftUI/Domains · high confidence

The macOS menu bar experience has been completely overhauled with new SwiftUI components. The Services section now displays services in a compact grid layout, allowing users to toggle individual services directly from the menu with visual feedback (checkmarks, error indicators, and progress spinners) and alerts for missing or errored services. A new Stats view presents PHP configuration limits (memory, post size, upload size) in a consolidated row with a direct link to the configuration GUI, replacing the previous layout.

phpmon/Domain/SwiftUI/Menu · high confidence

The Homebrew integration now uses a dedicated \BrewCommand\ protocol and implementation to manage shell operations, introducing more granular progress reporting for installation steps (fetching, downloading, installing, pouring) and better handling of command timeouts and termination statuses. This change ensures that output parsing and progress updates are performed safely on background threads using \OSAllocatedUnfairLock\ to prevent data races, while also supporting conditional execution of \brew trust\ commands based on system capabilities.

phpmon/Domain/Integrations/Homebrew/Commands · high confidence

The PHP monitoring logic has been restructured to improve reliability and concurrency. Detection of the active and installed PHP versions now uses a 'Probe' pattern that performs all blocking I/O (such as running \php-config\ and reading \.ini\ files) on background threads, preventing main-thread deadlocks. Configuration file handling is now thread-safe, with atomic writes and reloads to prevent race conditions when editing settings. Additionally, the system now robustly handles edge cases, such as missing PHP binaries, unparseable version strings, and unreadable configuration files, ensuring the application remains stable even with incomplete or corrupted PHP installations.

phpmon/Common/PHP · high confidence

The PHP version management logic has been restructured to improve robustness and concurrency safety. The new \PhpEnvironments\ class centralizes PHP installation tracking, using thread-safe locking to prevent race conditions during version detection and switching. Version comparison now relies on a new \VersionNumber\ model that supports strict and non-strict matching modes, allowing the app to correctly handle Homebrew's imprecise version reporting versus installed patch versions. Additionally, the system now supports Composer-style wildcard constraints (e.g., \^7.0\, \\~8.1\) for filtering available PHP versions, ensuring that extension compatibility checks align with user-defined requirements.

phpmon/Common/PHP/PHP Version · high confidence

The PHP version management commands (ModifyPhpVersionCommand and RemovePhpVersionCommand) have been rewritten to use Swift concurrency, ensuring the UI remains responsive during Homebrew operations. The modification process now explicitly handles major version upgrades that might break existing installations by reinstalling and relinking the previous version, and it automatically repairs unhealthy PHP installations after changes. Removal operations now include a 5-minute timeout to prevent hanging, verify the command's success status, and automatically switch the active PHP version back to the one that was active before the removal.

phpmon/Domain/Integrations/Homebrew/Commands/PHP Versions · high confidence

The application's dependency injection container has been restructured to separate production and test configurations. A new \Container+Fake\ extension provides a \fake()\ factory method that allows unit tests to inject mock shells, file systems, commands, and web API responses without affecting the host system. The core \Container\ now uses explicit \bind()\ and \overrideFake()\ methods to manage service initialization, ensuring that test environments are isolated from real OS interactions while maintaining the same service interface for production code.

phpmon/Container · high confidence

The file-watching logic in phpmon/Domain/Watcher has been restructured to improve reliability and performance. A new Debouncer actor prevents rapid, repeated events from triggering excessive processing by waiting for a specified interval before executing actions. The FSNotifier actor now supports suspension, allowing the HomebrewWatchManager to temporarily pause monitoring of /homebrew/bin during package installations or updates to avoid duplicate work. Additionally, the ConfigWatchManager has been introduced to manage PHP configuration file changes with similar debouncing, ensuring the menu updates smoothly without redundant reloads.

phpmon/Domain/Watcher · high confidence

The application's core shell interaction has been completely rewritten to support Swift concurrency and improve reliability. A new \Actions\ class now centralizes service management (linking PHP, restarting Nginx/PHP-FPM/DNSMasq) and configuration folder opening, while a new \AppleScript\ helper executes privileged commands via a subprocess to avoid main-thread deadlocks. Command building is now declarative using \ConditionalCommand\, allowing sequences to be filtered by condition, and the \Paths\ class has been refactored to use a \Sendable\ architecture with thread-safe binary detection. This change also introduces a new \Log\ class with granular verbosity levels and a \Constants\ struct that updates the supported PHP version matrix to include PHP 8.5 and 8.6, and adjusts the Valet support matrix for version 4.

phpmon/Common/Core · high confidence

The provisioning system now uses a new ZshRunCommand class to manage PATH entries in .zshrc, ensuring that Homebrew, Composer, and PHP Monitor binaries are added safely. This change prevents shell injection by escaping single quotes in user-provided paths and avoids duplicate entries by checking for existing paths using normalized path comparison. Additionally, file operations are performed asynchronously to prevent blocking the main actor, improving app responsiveness during onboarding and configuration.

phpmon/Domain/Provision · high confidence

The PHP Monitor self-updater (phpmon-updater) now shows a progress window when an update takes longer than 5 seconds, improving visibility during lengthy installations. This change is implemented by configuring the NVAppUpdater library with a \.whenUpdatingTakesLongerThan(5.0)\ display mode in the application's main entry point.

phpmon-updater · high confidence

The services management layer has been refactored to distinguish between active, inactive, missing, and error states for Homebrew services. When a service fails to start or stops unexpectedly, the application now displays a specific error status in the menu bar and presents a troubleshooting alert to the user. If the service provides an error log path, the alert includes a button to open the log file directly; otherwise, it shows a simplified message. This change improves visibility into service health and helps users resolve issues without leaving the application.

phpmon/Domain/App/Services · high confidence

The Settings window UI has been rebuilt using SwiftUI, replacing the previous storyboard/XIB implementation while preserving the original layout metrics, toolbar-style tabs, and row behaviors. This migration includes a fix for global shortcut recording: the hotkey listener is now scoped to the Settings window only, preventing unintended key capture from other application windows.

phpmon/Modules/Settings · high confidence

The application now resolves the user's PATH with a 3-second timeout and a fallback to the system PATH if the interactive shell hangs or fails. This change prevents startup deadlocks and excessive delays on constrained systems by ensuring that PATH retrieval does not block indefinitely, while also improving thread safety and concurrency handling in the shell execution layer.

phpmon/Common/Shell · high confidence

The terminal progress panel, which displays live console output during background operations, has been migrated from the legacy Storyboard-based implementation to a new SwiftUI architecture. This change introduces a dedicated \ProgressPanelView\ and \ProgressPanelModel\ to manage the UI state, replacing the previous \ProgressWindow.storyboard\. The visual layout, including the icon, title, description, and the black-on-white Menlo console text, has been preserved to ensure a consistent user experience while modernizing the underlying framework.

phpmon/Domain/Terminal Alert · high confidence

The Valet integration now uses a unified \DomainScanner\ protocol to resolve sites and proxies, replacing previous ad-hoc scanning logic. The new \ValetDomainScanner\ performs blocking filesystem operations (directory listings, certificate reads) off the main actor to prevent UI deadlocks and improve responsiveness on constrained systems, while safely handling invalid paths and missing directories without crashing. A \FakeDomainScanner\ is provided for testing, allowing deterministic resolution of mock sites and proxies.

phpmon/Domain/Integrations/Valet/Scanners · high confidence

The Valet integration now proactively alerts users about common configuration issues, including non-standard TLDs, outdated Valet versions, and broken PHP-FPM setups. It also defers loading the Valet configuration file until after initial app checks pass to prevent crashes from invalid JSON.

phpmon/Domain/Integrations/Valet · high confidence

The application now checks the expiration date of TLS certificates for Valet proxies and warns users when a certificate has expired. This is implemented by adding a \certificateExpiryDate\ property and an \isCertificateExpired\ computed property to the \ValetProxy\ class, along with logic in \apply(certificate:)\ to log a warning if the certificate is found to be expired. The \determine()\ and \refreshSecuredStatus()\ methods now validate the certificate and update the proxy's secured status and expiry date accordingly.

phpmon/Domain/Integrations/Valet/Proxies · high confidence

Added fake data handler for PHP version management; Added integration tests for concurrency, Homebrew compatibility, and privileged command isolation; Added test double for BrewCommand to support Swift 6 concurrency; Added test fixtures for Homebrew 7 service label compatibility; Added test plan configuration for PHP Monitor; Added test utilities for environment condition checks; Added tests for Logger thread safety and RunBlocking behavior; Added unit test fixtures for Valet configuration and Nginx stubs; Added unit tests for FSNotifier debouncing and lifecycle; Added unit tests for PHP Monitor parser components; Added unit tests for PHP version detection and environment management; Added unit tests for RealFileSystem and TestableFileSystem; Added unit tests for RealShell and TestableShell implementations; Added unit tests for Valet domain list, sidebar, and concurrency safety; Added unit tests for WarningManager trust diagnostics; Added unit tests for command execution, PHP health recovery, and shell configuration; Added unit tests for configuration handling and system context; Added unit tests for core PHP monitor logic; Added unit tests for the Web API integration; Added unit tests for the onboarding wizard and privileged command execution; Expanded UI test coverage for core application features; New TestableConfiguration for deterministic PHP environment simulation; Test infrastructure modernization and shared test utilities.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 60 (-0.5)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 95 → 95 (-0.1)
• Architecture 96 → 95 (-1.2)
• Maturity 63 → 63 (+0.0)
• Readiness 62 → 59 (-3.0)
• Security 80 → 80 (+0.0)
• Accessibility 51 → 51 (+0.0)

• Change coupling: Actions.swift ↔ HomebrewDecodable.swift (phpmon/Common/Core/Actions.swift)
• Change coupling: HomebrewDecodable.swift ↔ Startup.swift (phpmon/Common/PHP/Homebrew/HomebrewDecodable.swift)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Hotspot: phpmon/Domain/App/Services/ValetServicesDataManager.swift (phpmon/Domain/App/Services/ValetServicesDataManager.swift)
• Hotspot: phpmon/Domain/Menu/StatusMenu.swift (phpmon/Domain/Menu/StatusMenu.swift)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (phpmon/Domain/App/AppDelegate+InterApp.swift)

• Duplicated block (15 lines × 2) (phpmon/Modules/PHP Extension Manager/UI/PhpExtensionManagerView.swift)
• Duplicated block (39 lines × 2) (phpmon/Domain/SwiftUI/Domains/AddProxyView.swift)
• Duplicated block (7 lines × 3) (phpmon/Modules/PHP Doctor/UI/PhpDoctorView.swift)
• Duplicated block (8 lines × 2) (phpmon/Modules/PHP Config Editor/UI/ConfigManagerView.swift)
• Low cohesion: String (LCOM4 5) (phpmon/Common/Extensions/StringExtension.swift)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (phpmon/Domain/App/AppDelegate+InterApp.swift)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

nicoverbruggen/phpmon was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.