rsyncOSX/RsyncUI

RsyncUI is a macOS application that provides a graphical interface for managing rsync-based file synchronization, backup, and snapshot operations. It enables users to configure, schedule, and execute remote and local sync tasks while offering real-time progress tracking, detailed logging, and statistical visualization. The system supports deep linking, widget integration, and configuration import/export, all built on a modernized architecture using Swift concurrency and JSON storage.

51 changes.

The RsyncUI application underwent a comprehensive architectural overhaul, migrating from legacy Interface Builder and synchronous patterns to a modern SwiftUI-based interface with native macOS styling. The backend was refactored to utilize Swift Concurrency, async actors, and dedicated streaming libraries for process execution, replacing obsolete model classes and PLIST storage with a robust JSON-based persistence layer.

30 changes.

This period covers the initial release of the RsyncUI macOS application, establishing its core architecture with SwiftUI, async/await storage, and streaming rsync process handlers. It introduces foundational features including profile management, task estimation and execution, scheduling, and configuration import/export. The work also extends the app's reach through macOS widgets, deep link support, and an XPC service for cross-process calculations.

Users can now export selected synchronization configurations to a JSON file and import configurations from a JSON file. The new ExportView allows selecting specific tasks (excluding snapshots) and specifying an output filename and location, while the ImportView provides a file picker to load configurations, with an option to import all or only selected tasks from the imported file.

RsyncUI/Views/ExportImport · high confidence

New Swift files have been added to handle reading and writing synchronization configurations to and from JSON files. The \ReadImportConfigurationsJSON\ module decodes imported configurations, assigns new unique IDs, and clears run dates to ensure imported items are treated as fresh entries. The \WriteExportConfigurationsJSON\ module serializes the current list of configurations into a JSON file at a specified path, providing user-facing alerts if the write operation fails.

RsyncUI/Model/Storage/ExportImport · high confidence

A new Verify Task tab has been added to the inspector, allowing users to preview synchronization changes via a streaming dry-run. The view provides a command previewer that displays the specific rsync arguments for the selected configuration and includes toolbar buttons to start the verification or abort the running process. Upon completion, the interface presents a summary of the remote data numbers and changes detected during the dry run.

RsyncUI/Views/InspectorViews/VerifyTask · high confidence

This change introduces the WidgetEstimate widget extension, which displays the current synchronization profile and status for files managed by the RsyncUI app. The widget reads configuration from a shared JSON storage file to show the active profile name and a timestamp, using visual indicators (yellow for active, red for no URL set) to reflect the connection state. It integrates with the RsyncUIDeepLinks framework to validate URLs and supports opening the main app via widget URLs.

WidgetEstimate · high confidence

A new XPC service has been added to the project, enabling cross-process communication for a simple calculation feature. The service exposes a protocol allowing callers to perform integer addition via \performCalculation\, with the service side configured to run within an app sandbox.

XPC · high confidence

Users can now access key actions directly from the application menu bar. The 'Tasks' menu provides buttons to start estimation, start synchronization, abort tasks, and toggle the Quick & Chart view, each with associated keyboard shortcuts. The 'Import & Export' menu replaces the standard import/export placement with dedicated buttons for exporting and importing tasks. Additionally, a 'Snapshots' menu includes a 'Tag snapshot' button with a keyboard shortcut.

RsyncUI/Views/Tools · high confidence

Introduces a new mechanism to save and validate widget URL strings (specifically for the Estimate widget) to the app's sandboxed Documents directory. The system now validates the URL string using RsyncUIDeepLinks before writing it to a JSON configuration file, ensuring that only valid URLs are persisted to permanent storage.

RsyncUI/Model/Storage/Widgets · high confidence

This change introduces the core macOS application structure for RsyncUI, including the main app entry point (RsyncUIApp.swift) and the primary user interface view (RsyncUIView.swift). The application features a main window for managing rsync profiles and tasks, a dedicated log window for viewing output, and a settings view. It integrates with the system for handling external URL schemes, manages application lifecycle events such as cleanup on termination, and utilizes modern SwiftUI concurrency patterns for configuration loading and UI updates.

RsyncUI/Main · high confidence

Added the DeeplinkURL struct in RsyncUI/Model/Deeplink/DeeplinkURL.swift to centralize deep link processing. This component validates URL schemes, handles valid deep link queries, verifies profile names against available records, and constructs URLs for synchronization actions, displaying alerts to the user when errors occur during these operations.

RsyncUI/Model/Deeplink · high confidence

Adds a new scheduling interface in the ScheduleView area, featuring a month grid (CalendarMonthView) for visualizing and selecting dates, an AddSchedule form for creating new tasks, and tables (TableofSchedules, TableofNotExeSchedules) for managing existing and unexecuted schedules. The UI now displays a 'Time last' column in schedule tables and provides specific views for schedules that were not executed after a system wakeup, allowing users to move or delete them.

RsyncUI/Views/ScheduleView · high confidence

Users can now configure schedules to run weekly, in addition to the existing once and daily options, via the new ScheduleType enum. The SchedulesConfigurations struct and its associated DecodeSchedules helper have been introduced to manage schedule data, including profile, date added, date run, and schedule type, enabling the storage and decoding of these new weekly schedule configurations.

RsyncUI/Model/Schedules · high confidence

Adds the ActorLogToFile actor to handle writing, reading, and resetting the application's log file. This change introduces automatic enforcement of a maximum log file size, where the system checks the file size during read operations and resets the log if it exceeds the configured limit, ensuring logs do not grow indefinitely. It also provides methods to append new log entries and reset the log file manually.

RsyncUI/Model/Storage/Actors · high confidence

A new LogfileView has been added to the RsyncUI interface, providing a table-based display of rsync output log lines. This view includes a 'Reset' button that allows users to clear the current logfile and reload the log content, enhancing control over the logging output within the application.

RsyncUI/Views/LogView · high confidence

The RsyncParameters inspector now features a dedicated editor for rsync arguments (via EditRsyncParameter) and a 'Danger Zone' section that allows users to toggle the --delete flag with a clear warning. It also includes SSH configuration fields for key paths and ports, which now perform real-time validation (checking for tilde prefixes, path existence, and valid port ranges) and display error borders when inputs are invalid.

RsyncUI/Views/InspectorViews/RsyncParameters · high confidence

The Tasks area now features a dedicated navigation stack in SidebarTasksView that routes to new views for task management. ExecuteEstTasksView and ExecuteNoEstTasksView handle the execution of estimated and non-estimated tasks respectively, providing progress feedback and abort capabilities. A new CompletedView displays a success message upon task completion, while LogStatsChartView allows users to visualize synchronization statistics as line or bar charts, filtering by files or data size. The main TasksView coordinates these flows, integrating focus actions and toolbar controls for estimation, synchronization, and scheduling.

RsyncUI/Views/Tasks · high confidence

The Detailsview area now includes a suite of new SwiftUI views to manage the estimation and execution phases of synchronization tasks. Users will see an EstimationInProgressView that displays a progress bar and an EstimateTableView listing configurations with their Synchronize IDs, sources, and destinations. Once estimation completes, the SummarizedDetailsView presents a detailed breakdown of file changes (new, deleted, updated) in a table, allowing users to review data before execution. A new TimerView provides a countdown mechanism in the toolbar, giving users a brief window to cancel the synchronization before it automatically starts.

RsyncUI/Views/Detailsview · high confidence

Added DetailsView, DetailsViewHeading, and OutputRsyncView to display rsync synchronization results. DetailsViewHeading presents metadata including the Synchronize ID, Task, Source, Destination, Server, and file/directory/byte totals. DetailsView shows a summary of changes (new files, files to delete, files changed, and transfer size) with pluralization logic, and conditionally renders an ItemizedOutputRow table if itemization is enabled, otherwise showing raw output rows. OutputRsyncView provides a dedicated table view for raw rsync output records. A URL extension was also added to expose the user's home directory path.

RsyncUI/Views/OutputViews · high confidence

Users can now manage rsync backup profiles directly from the UI. A new 'Manage Profiles' screen allows creating, selecting, and deleting profiles via a dedicated sheet and confirmation dialog. Additionally, a configuration table displays the synchronization status of each profile, showing the last run time and date, with visual indicators for profiles that have not been updated within the configured threshold.

RsyncUI/Views/Profiles · high confidence

Added a new model layer to handle checking for RsyncUI updates. This includes a \CheckfornewversionofRsyncUI\ observable class to manage UI state for notifications and downloads, and a \GetversionofRsyncUI\ actor to fetch and cache version data from a remote JSON resource, filtering for the currently running version.

RsyncUI/Model/Newversion · high confidence

The \VerifyJSON\ class and its associated error types have been removed from the application. This class previously handled the validation of JSON configuration and schedule data by comparing it against Plist-based records, ensuring record counts matched and struct equality held for configurations and schedules. Its removal eliminates the built-in mechanism for verifying that JSON storage formats are consistent with their Plist counterparts.

RsyncUI/Model/JSON · high confidence

The Logfile model class has been removed from the application. This class previously handled the creation, reading, and writing of log files, including logic for checking file sizes and propagating errors when logs exceeded a configured limit. Its removal indicates that the application no longer persists or manages local log files through this component.

RsyncUI/Model/Logfile · high confidence

The LogfileView SwiftUI component has been removed from the application. This view previously displayed a list of log records and provided a button to reset the log file. Its deletion indicates that this specific log viewing interface is no longer part of the user experience.

RsyncUI/Views/FilelogView · high confidence

The \RsyncUI/Model/ComputeParametersRsync\ module has been removed, deleting the classes responsible for constructing rsync command-line arguments. Specifically, \ArgumentsLocalcatalogInfo\, \ArgumentsRestore\, \ArgumentsSynchronize\, \ArgumentsVerify\, and the base \RsyncParameters\ class are no longer present. This eliminates the logic that previously assembled rsync flags based on configuration settings, including SSH parameter handling and task-specific argument generation.

RsyncUI/Model/ComputeParametersRsync · high confidence

The RsyncCommandView SwiftUI component, which previously displayed rsync command configurations, parameter lists, and allowed users to copy commands to the clipboard, has been removed from the application.

RsyncUI/Views/RsyncCommand · high confidence

The Single Tasks view and the associated output display view have been removed from the application. Users can no longer initiate single rsync tasks (estimate or execute) or view their output through these specific UI components.

RsyncUI/Views/Singletask · high confidence

The \SingleTaskNow\ execution logic has been removed from the application. This change deletes the \ExecuteSingleTaskNow\ class, its \ShellOut\ variant (which handled pre/post tasks), and the associated \SingletaskNowState\ observable object. Users will no longer be able to trigger immediate, single-task rsync executions through this specific model layer.

RsyncUI/Model/Execution/SingleTaskNow · high confidence

The default UI test class file (RsyncUIUITests.swift) has been removed from the project. This eliminates the boilerplate test structure that previously included a basic launch test and a performance measurement test, meaning the application no longer includes these specific UI test cases by default.

RsyncUIUITests · high confidence

The legacy SwiftUI views for adding and managing rsync configurations have been removed from the application. Specifically, the \AddConfigurationsView\ (which handled task type selection, local/remote paths, and pre/post tasks), the confirmation dialogs (\ConfirmAddView\, \ConfirmUpdatedView\), and the configuration selection interface (\SelectConfigurationView\) are no longer present in the codebase.

RsyncUI/Views/Add · high confidence

The \SetRsyncParameters.swift\ and \SuffixstringsRsyncParameters.swift\ files in the \RsyncUI/Model/AddParametersRsync\ directory have been deleted. This removes the internal logic that previously managed rsync argument parsing, configuration mapping, and predefined parameter lists (such as backup and suffix options) for the Rsync UI model.

RsyncUI/Model/AddParametersRsync · high confidence

The Schedules tab's user interface has been removed from the application. This change deletes the \SchedulesView\ and its associated sub-components (\ScheduleRowSchedules\, \SchedulesList\, and \SchedulesDatePickerView\), eliminating the ability to view, add, or manage backup schedules through this specific UI section.

RsyncUI/Views/Schedules · high confidence

The legacy data management classes in the RsyncUI model layer have been removed. Specifically, \ConfigurationsSwiftUI\, \SchedulesSwiftUI\, \RsyncOSXdata\, \OutputFromRsync\, and \OutputFromMultipleTasks\ have been deleted from the \RsyncUI/Model/Data\ directory. This change eliminates the previous implementation of configuration, schedule, and output data handling within this specific module.

RsyncUI/Model/Data · high confidence

The \Userconfiguration\ struct, which previously handled reading user settings (such as rsync version, logging levels, paths, and SSH details) from a dictionary into the shared application state, has been removed. This eliminates the legacy mechanism for initializing and validating these specific user preferences.

RsyncUI/Model/Userconfiguration · high confidence

The \ArgumentsOneConfiguration\, \Equal\, \UpdateConfigurations\, and \VerifyConfiguration\ model files have been removed from the \RsyncUI/Model/Data/Configurations\ directory. This deletion eliminates the previous logic for computing rsync arguments, managing configuration persistence, and validating backup configurations, indicating a structural shift in how the application handles configuration data and validation.

RsyncUI/Model/Data/Configurations · high confidence

The \RsyncUI/Model/Storage/Conversions\ directory has removed four Swift files (\ConvertAssist\, \ConvertConfigurations\, \ConvertSchedules\, and \ConvertUserconfiguration\) that previously handled the conversion of internal model objects into \NSDictionary\ and \NSMutableDictionary\ structures for storage. This change eliminates the manual mapping logic for task configurations, schedules, user settings, and assist assets, indicating a shift away from the legacy dictionary-based serialization format used in previous versions of RsyncOSX.

RsyncUI/Model/Storage/Conversions · high confidence

The \ExecuteMultipleTasks\, \ExecuteOneTask\, and \MultipleTaskState\ classes in the \RsyncUI/Model/Execution/ExecuteMultipleTasks\ directory have been removed. This eliminates the previous implementation responsible for queuing, executing, and tracking the state of multiple Rsync tasks sequentially.

RsyncUI/Model/Execution/ExecuteMultipleTasks · high confidence

The \InterruptProcess\, \OtherProcessCmdClosure\, and \RsyncProcessCmdClosure\ classes in the main process model have been removed. These classes previously handled the execution of external commands (including rsync), managed process output via pipes, and monitored network connectivity for offsite transfers. Their removal indicates a shift away from this specific implementation of background process management.

RsyncUI/Model/Process/Main · high confidence

The \Reorgschedule\ and \UpdateSchedules\ classes have been removed from the application. This eliminates the code responsible for managing backup schedules (adding, stopping, deleting, and merging schedule records) and the associated helper functions for unique element handling, indicating that schedule management functionality has been refactored or moved to a different location in the codebase.

RsyncUI/Model/Data/Schedules · high confidence

The About view (AboutView.swift) has been removed from the application. Users will no longer see the screen displaying the app version, copyright information, and links to the changelog and documentation.

RsyncUI/Views/About · high confidence

The legacy estimation implementation in the RsyncUI model layer has been removed. Specifically, the \Estimation\, \EstimationOnetask\, \EstimationState\, and \RemoteinfonumbersOnetask\ classes and structs located in \RsyncUI/Model/Execution/Estimation\ have been deleted. This eliminates the previous logic for managing estimation states, processing individual rsync dry-run tasks, and aggregating remote file information (such as transferred numbers and delete counts) during the estimation phase.

RsyncUI/Model/Execution/Estimation · high confidence

The \RsyncUI/Views/Multitask\ directory has been cleaned up by removing five SwiftUI view files: \DeleteConfigurationsView\, \EstimationView\, \ExecuteAlltasksView\, \ExecuteEstimatedView\, and \OutputEstimatedView\. These views previously provided the user interface for estimating, executing, and managing the output of multiple rsync configurations, including progress tracking and confirmation dialogs. Their removal indicates that this specific multitask workflow is no longer supported or has been replaced by a different implementation elsewhere in the application.

RsyncUI/Views/Multitask · high confidence

The \InprogressCountExecuteOneTaskDetails\, \InprogressCountMultipleTasks\, and \InprogressCountRsyncOutput\ model classes have been deleted from the \RsyncUI/Model/Execution/ProgressCounts\ directory. These classes previously handled specific aspects of task progress tracking, such as single-task details, multiple-task estimation, and rsync output parsing. Their removal indicates a refactoring of the execution progress model, likely consolidating or replacing this logic with a different implementation elsewhere in the application.

RsyncUI/Model/Execution/ProgressCounts · high confidence

The \ExecuteSingleTask\ class and the \SingleTaskState\ observable object have been removed from the application. This eliminates the previous mechanism for managing the lifecycle, state updates, and execution of individual rsync tasks, indicating a shift in how single-task operations are handled within the UI.

RsyncUI/Model/Execution/SingleTask · high confidence

The build process has been restructured to support separate arm64 and x86\_64 targets, with the unified Makefile now handling x86\_64 builds and a new Makefile-arm64 managing Apple Silicon builds. This change includes the addition of SwiftFormat and Periphery configuration files to enforce code formatting and detect unused code, alongside updated SwiftLint rules and a revised .gitignore to better manage build artifacts and Swift Package Manager files.

(repo-wide) · high confidence

The RsyncUI Xcode project has been updated to objectVersion 70, reflecting a significant structural change in the project.pbxproj file. This migration replaces older build file references with new ones for key frameworks, specifically adding SSHCreateKey, ProcessCommand, and DecodeEncodeGeneric, while removing references to legacy components like ShellOut and Files. This change aligns the project configuration with modern Xcode standards and updates the underlying dependency wiring for the application.

RsyncUI.xcodeproj · high confidence

A new Xcode scheme file (RsyncUI.xcscheme) has been added to the project, defining the build, test, launch, profile, analyze, and archive actions for the RsyncUI application. This configuration enables developers to run, debug, and test the app directly within Xcode using the specified build configurations and debugger settings.

RsyncUI.xcodeproj/xcshareddata · high confidence

The Xcode workspace configuration now explicitly disables SwiftUI Previews (PreviewsEnabled set to false) to prevent them from running during builds or editing. Additionally, a new file reference to refactor.md has been added to the workspace contents, making the documentation file visible and accessible within the Xcode workspace navigator.

RsyncUI.xcodeproj/project.xcworkspace · high confidence

The inspector panel in the RsyncUI has been redesigned to use a segmented picker for tab navigation, replacing the previous layout. Users can now switch between four distinct tabs—Edit, Parameters, Logs, and Verify—within the inspector. This change introduces new view components (EditTabView, InspectorContentView, InspectorView) that manage the task list, inspector content, and tab selection logic, providing a more organized interface for managing rsync configurations and viewing logs.

RsyncUI/Views/InspectorViews · high confidence

The RsyncUI now uses a new streaming execution model (via the RsyncProcessStreaming package) to process rsync output line-by-line, enabling real-time progress updates and immediate error detection. This change introduces dedicated handler factories (CreateStreamingHandlers) that support file-count callbacks, process termination events, and automatic resource cleanup to prevent retain cycles. Error handling is improved with a new RsyncFailureAlert that summarizes the last 10 lines of stderr for user display, and a StreamingProcessOutcome enum that accurately distinguishes between success, failure, and cancellation (e.g., signal 20) based on exit codes and error flags. Debug-only threading checks ensure streaming callbacks do not block the main actor.

RsyncUI/Model/Execution/CreateHandlers · high confidence

The application has replaced the legacy Combine-based \ObserveableReference\ and \Extensions\ with modern \@Observable\ classes (such as \ObservableLogSettings\, \ObservableSSH\, and \ObservableProfiles\) and the new \GlobalTimer\ for schedule management. This change updates the underlying state management to use Swift's native concurrency model, improving reliability and simplifying the codebase for users by ensuring consistent data flow across settings, profiles, and scheduled tasks.

RsyncUI/Model/Global · high confidence

The UI modifier views have been updated to adopt native SwiftUI styling and improve visual consistency. Button styles now automatically use the new .glassProminent and .glass button styles on macOS 26+, falling back to .borderedProminent on earlier versions. The toggle view has been refactored to use standard toggle styles and respects the system's dark mode color scheme for text and borders. Additionally, message views now dynamically adjust their text color based on the current color scheme (green for dark mode, blue for light mode) and utilize modern .foregroundStyle modifiers.

RsyncUI/Views/Modifiers · high confidence

The application introduces a new \Estimate\ and \Execute\ architecture for handling rsync operations, replacing the previous implementation. The \Estimate\ class now performs dry-run synchronizations to calculate transfer sizes and validate arguments before execution, while the \Execute\ class manages the actual file transfers. This change includes a new \RemoteDataNumbers\ model to parse and display detailed rsync statistics (files transferred, sizes, directories) and integrates with \RsyncProcessStreaming\ for real-time progress updates. Users will experience more accurate pre-sync estimates and improved handling of missing or malformed rsync output stats, which now default to zero values instead of causing errors when the 'silence missing stats' option is enabled.

RsyncUI/Model/Execution/EstimateExecute · high confidence

The Quicktask view now executes rsync commands using the RsyncProcessStreaming package instead of the previous synchronous or older process handling. This change introduces a new ObservableRsyncOutput model to capture and display streaming output, updates the UI to show a progress view during execution, and adds toolbar buttons for clearing the form, starting synchronization, and aborting the process. The view also integrates with AppStorage for persisting user inputs and uses a new QuicktaskFormView to handle the configuration form.

RsyncUI/Views/Quicktask · high confidence

The Restore view has been rebuilt to provide a clearer, more interactive experience. Users now see a dedicated file list table for selecting items to restore, a controls panel for choosing the destination folder and toggling preview mode, and a new circular progress indicator that displays real-time status during the restore operation.

RsyncUI/Views/Restore · high confidence

The Add inspector view has been refactored to provide a clearer, more structured experience for creating and editing Rsync tasks. The interface now uses a grouped Form layout with distinct sections for Synchronize ID, Folders, and Remote settings, replacing the previous flat structure. A new 'Action' picker allows users to select between Synchronize, Snapshot, and SyncRemote task types, dynamically adjusting the form fields (e.g., showing/hiding Snapshot Number or swapping Source/Destination labels). Validation is improved with visual error borders on required fields when dependencies are missing, and a new 'VerifyDuplicates' check prevents saving tasks with conflicting IDs. The view also supports both inspector-side editing and a dedicated sheet mode for adding new tasks, with consistent state management for selection and profile changes.

RsyncUI/Views/InspectorViews/Add · high confidence

The storage layer for schedules, synchronize configurations, and log records has been rewritten to use new dedicated async actors (SharedJSONStorageReader and SharedJSONStorageWriter) instead of the previous synchronous, class-based ReadWriteJSON and ReadWriteDictionary helpers. This change moves JSON decoding and encoding off the main thread using detached tasks, ensuring that reading and writing configuration files no longer blocks the UI, and replaces the old file-handling classes with a cleaner, actor-isolated persistence model.

RsyncUI/Model/Storage · high confidence

The SSH key management logic in the RsyncUI model has been significantly refactored. The previous \Ssh.swift\ implementation, which relied on local helper classes like \ArgumentsSsh\ and \OtherProcessCmdClosure\, has been replaced by a new \SshKeys.swift\ class. This new implementation integrates the \SSHCreateKey\ library for key generation and validation, and switches command execution to the \ProcessCommand\ package. Additionally, the code now utilizes \ProcessCommandAsyncSequence\ for handling process output and logging, improving consistency and reliability in SSH key operations.

RsyncUI/Model/Ssh · high confidence

The JSON storage layer for user and synchronize configurations has been restructured. User configuration now explicitly supports new settings including 'confirm execute', 'silence missing stats', and 'validate arguments', while removing obsolete fields. Synchronize configuration models have been renamed and simplified: unused parameters (1, 2, 3, 5, 6) and pre/post-task fields have been removed, replaced by a 'halted' state, and the 'halt shell tasks on error' option is no longer decoded. Log record decoding has been moved to a dedicated file with a simplified structure, and the overall codebase has been cleaned up with doc comments and SwiftLint compliance.

RsyncUI/Model/Storage/Basic/JSON · high confidence

The rsync version detection logic has been rewritten to use the RsyncProcessStreaming library for asynchronous execution, replacing the previous synchronous command-execution approach. This change introduces a new InterruptProcess component that allows users to immediately cancel running operations without waiting for logs to flush, and removes obsolete classes (RemoteCapacity, RsyncOSXViewGetRsyncversion, RsyncVersionString) that are no longer needed for this workflow.

RsyncUI/Model/Process · high confidence

The snapshot model layer has been refactored to replace the legacy \RsyncProcessCmdClosure\ and \OutputProcess\ with the \RsyncProcessStreaming\ package for executing rsync commands, enabling streaming output handling. This change introduces new model classes (\DeleteSnapshots\, \RecordsSnapshot\, \SnapshotRemoteCatalogs\) and updates \Snapshotlogsandcatalogs\ and \TagSnapshots\ to use \ObservableSnapshotData\ and \LogRecordSnapshot\, standardizing time formatting and improving error handling. The refactoring also removes deprecated \SnapshotData\ and simplifies date logic by replacing manual component extraction with direct \Date\ extensions.

RsyncUI/Model/Snapshots · high confidence

The socket utility library in RsyncUI/Model/Utils/yudpsocket has been refactored to improve code clarity and consistency. The generic Result enum has been renamed to ResultYTP and its property implementations simplified to use implicit returns. The TCPClient and TCPServer classes now return ResultYTP instead of the old Result type, and internal variable access has been cleaned up by removing redundant self prefixes. Additionally, C-style comments have been removed in favor of Swift's native syntax, and SwiftLint directives have been adjusted to manage line length and identifier naming rules.

RsyncUI/Model/Utils/yudpsocket · high confidence

The text value editing views in RsyncUI have been restructured to improve visual feedback and usability. A new EditValueErrorScheme view was introduced to handle error states, displaying text in red when an error is present and adapting to light or dark color schemes. The existing EditValueScheme view (renamed from EditValue) now supports placeholder prompts via a new prompt parameter and applies foreground styling that respects the system's color scheme, ensuring consistent appearance across themes.

RsyncUI/Views/TextValues · high confidence

The Log Records inspector view has been restructured into dedicated components, introducing a new footer that displays the total log count and any active filter criteria. Search functionality is now conditional, appearing only when the Log View tab is active, and includes a debounce mechanism to delay filtering updates while the user types. The interface also features a custom empty-state overlay that distinguishes between 'no results' and 'sorting logs' states, and uses modern SwiftUI styling for icons and text.

RsyncUI/Views/InspectorViews/LogRecords · high confidence

The file catalog and path management logic in the model layer has been rewritten to replace the legacy 'Files' library and complex class inheritance with standard Foundation APIs. The new implementation introduces dedicated services: \HomeCatalogsService\ for listing home directories, \CatalogForProfile\ for creating and deleting profile folders, and \Homepath\ for managing configuration paths and serial numbers. This change removes the previous \Catalogsandfiles\, \NamesandPaths\, \Keypathidentityfile\, and \CatalogProfile\ classes, simplifying the architecture and removing the external dependency.

RsyncUI/Model/FilesAndCatalogs · high confidence

The logging subsystem in RsyncUI has been rewritten to replace the previous in-memory schedule-based storage with a dedicated JSON-based log record system. The old classes (SingletaskPrimaryLogging, MultipletaskPrimaryLogging, AllLoggs) that managed schedules and configurations directly have been removed and replaced by new services: LogStoreService handles asynchronous loading and saving of log records from JSON files, Logging manages the creation and persistence of individual log entries, and LogChartService provides data reduction logic for charting metrics like file counts and transfer sizes. This change shifts log persistence from the application's schedule configuration objects to a separate, dedicated JSON store, improving separation of concerns and enabling async data access.

RsyncUI/Model/Loggdata · high confidence

The progress tracking logic in the RsyncUI model has been refactored to improve clarity and support different execution modes. A new \NoEstProgressDetails\ class was introduced to handle scenarios where no estimation is performed, managing execution lists and UUIDs separately from the main estimation flow. The existing \ProgressDetails\ class was updated to use the \Observation\ framework for state management and standardized logging via \debugMessageOnly\. Additionally, the logic for calculating maximum counts during execution now applies version-specific reductions (15 for rsync v3, 13 for openrsync) to account for summarized status rows in the output, ensuring more accurate progress reporting.

RsyncUI/Model/Execution/ProgressDetails · high confidence

The rsync argument generation logic in the ParametersRsync module has been restructured into a set of specialized classes (ArgumentsRemoteFileList, ArgumentsRestore, ArgumentsSnapshotRemoteCatalogs, ArgumentsSynchronize, and ArgumentsVerify) that delegate to a new Params struct and SSHParams struct. This change centralizes the mapping of SynchronizeConfiguration to internal Parameters, improving how SSH settings (port, key path) and optional flags (like delete extraneous) are handled, and ensures consistent argument assembly for synchronization, restoration, and verification tasks.

RsyncUI/Model/ParametersRsync · high confidence

The monolithic OutputProcess class has been removed and replaced by a modular set of output handlers. TrimOutputFromRsync now handles streaming output and error detection, while TrimOutputForRestore specifically formats restore lists. A new ItemizedOutput system parses rsync's itemized output codes into structured records with visual indicators (Added, Updated, Deleted, Metadata) for the UI. CreateOutputforView centralizes the creation of view models from raw rsync strings, including support for log file records.

RsyncUI/Model/Output · high confidence

The snapshot argument construction logic has been refactored to use new dedicated model classes (ArgumentsSnapshotCreateCatalog and ArgumentsSnapshotDeleteCatalogs) that delegate to the RsyncArguments library, replacing the previous manual SSH and rsync argument builders. For snapshot deletion, the system now enforces strict path validation to prevent invalid or unsafe folder names and adds proper shell quoting for remote commands, ensuring that only valid numbered snapshots within the configured root can be removed.

RsyncUI/Model/ProcessArguments · high confidence

The dedicated SwiftUI view wrappers for UI icons and progress indicators in the Images directory have been removed. This includes components for sidebar and command icons (such as ImageRsync, ImageSettings, and ImageSchedules), task-specific indicators (ImageSingletask, ImageExecuteMultitask), and custom progress views (ImageProgressview, ImageZstackProgressview). Users will no longer see these specific pre-styled icon and progress representations, as the underlying view structures have been deleted.

RsyncUI/Views/Images · high confidence

The PLIST-based storage implementations for configurations, schedules, and user settings have been removed from the application. This change eliminates the \PersistentStorageConfigurationPLIST\, \PersistentStorageSchedulingPLIST\, and \PersistentStorageUserconfiguration\ classes, along with the central \PersistentStorage\ coordinator that managed the switch between JSON and PLIST formats. Users will no longer be able to read or write application data using the legacy PLIST format; all persistent storage operations are now handled exclusively through the JSON-based classes (\PersistentStorageConfigurationJSON\ and \PersistentStorageSchedulingJSON\).

RsyncUI/Model/Storage/PersistentStorage · high confidence

The \Main.storyboard\ file, which defined the application's main menu (including options for Synchronize, Estimate, Logfile, and Print) and standard system menus, has been deleted. This change removes the legacy XIB-based UI definition for the RsyncUI application, indicating a migration away from Interface Builder storyboards for the main window.

RsyncUI/Base.lproj · high confidence

The configuration list has been migrated from the legacy \ConfigurationsList\ (which used \List\ and \OneConfig\ views) to a new \ConfigurationsTableDataMainView\ backed by SwiftUI's \Table\. This change introduces a richer user experience with a dedicated progress column that displays animated numeric percentages and status text (e.g., 'syncing...', 'halted') for active tasks, alongside a 'Last Sync' column that shows relative time (e.g., '2 hours ago') and staleness indicators. The new table supports real-time filtering via a search bar, multi-selection for batch operations (delete, copy/paste), and context menus for halting tasks, replacing the previous static row-based display.

RsyncUI/Views/Configurations · high confidence

The storage models for task configurations (SynchronizeConfiguration) and user settings (UserConfiguration) have been refactored to use native Codable initializers instead of dictionary-based parsing, and several unused parameters (parameter1-3) have been removed from the data structures. Validation for snapshot and sync-remote tasks now explicitly requires rsync version 3.x, and the system enforces that local and remote catalogs are non-empty while ensuring remote usernames and servers are provided together. The new VerifyObservableAddConfiguration struct provides immediate validation feedback for the add-task UI, and the UpdateConfigurations class now validates that hidden IDs are unique before persisting changes.

RsyncUI/Model/Storage/Basic · high confidence

The RsyncUI/Model/Utils module has been significantly refactored to modernize the codebase and remove obsolete features. Several legacy utility classes and structs (including Alerts, Checkfornewversion, Dateandtime, GetConfigurationData, NetworkMonitor, Neworoldprofilepath, Notifications, Numbers, PreandPostTasks, RemoteNumbers, Running, and Validatenewconfigs) have been removed. New utility files have been introduced to replace or augment existing functionality: FileSize for checking log file sizes, OtherRsyncCommandtoDisplay for generating and formatting rsync command strings (including SSH key operations), PrepareOutputFromRsync for trimming and formatting rsync output, ReadAllTasks for asynchronously reading and filtering task configurations, and ValidateArguments for enforcing rsync argument constraints (such as compression, archive mode, and dry-run flags). Additionally, the Environment struct was renamed to MyEnvironment and marked as @MainActor, and the Date and String extensions were consolidated and updated to use modern Swift formatting APIs.

RsyncUI/Model/Utils · high confidence

The RsyncUI application's entry point has been modified by removing the previous AppDelegate implementation, which previously handled window creation, profile catalog initialization, and menu actions like preferences and logging. Concurrently, a new Info.plist file has been added to define the app's bundle properties, including the custom URL scheme 'rsyncuiapp' and application category. This change alters the fundamental startup and configuration structure of the RsyncUI component.

RsyncUI · medium confidence

The settings interface has been completely reorganized into a sidebar-based navigation layout (SidebarSettingsView) that provides dedicated views for Rsync and Path, Log, SSH, Environment, and About information. The previous monolithic Usersettings and Othersettings views have been removed and replaced with these focused components, introducing new user-configurable options such as 'Suppress missing stats warnings', 'Validate rsync arguments', and 'Confirm execute' in the Log settings, while the SSH settings now feature a simplified global configuration for key paths and ports with validation feedback.

RsyncUI/Views/Settings · high confidence

The sidebar interface has been rebuilt to use a new \SidebarMainView\ and \SidebarPanel\ structure, replacing the previous \RsyncUIView\ and \Sidebar\ components. This change introduces a modernized navigation model with distinct tabs for Synchronize, Tasks, Snapshots, Restore, and Profiles, and integrates a new \SidebarStatusMessagesView\ to display system status indicators such as version updates, volume mounting, and scheduled task alerts. The refactoring also consolidates deep-link URL handling and volume-mounting observers into the new sidebar extension, streamlining how external commands and system events trigger profile loads and task executions.

RsyncUI/Views/Sidebar · high confidence

The Snapshots view has been refactored to use a native SwiftUI Table instead of the previous List-based layout, providing a more structured display of snapshot details (Snap, Date, Tag, Last, Result) with column width constraints. The deletion workflow has been improved: users can now select multiple snapshots for deletion via the table selection mechanism, triggering a confirmation dialog that accurately reflects the count of selected items, and the delete action is handled asynchronously with a progress indicator. Additionally, the view now supports filtering snapshots by date or tag via a search field, and includes a new toolbar button to delete unused log records, with a badge indicating the count of such records.

RsyncUI/Views/Snapshots · high confidence

The application now uses dedicated asynchronous methods to read and write user settings to a JSON file on disk. Configuration data is loaded in the background via \ReadUserConfigurationJSON\, and changes are saved via \WriteUserConfigurationJSON\, ensuring that UI interactions are not blocked during storage operations. This replaces previous synchronous handling with a modern async/await approach using \SharedJSONStorageReader\ and \SharedJSONStorageWriter\.

RsyncUI/Model/Storage/Userconfiguration · high confidence

Added the RsyncUITests target with a broad set of unit tests covering core application logic. The tests verify rsync argument generation for synchronize and syncremote tasks, deeplink URL creation and profile validation, and itemized output parsing for both standard and openrsync formats. They also cover the log chart reducer's daily aggregation, log store service filtering and deletion, schedule management including timer rescheduling and horizon validation, configuration validation for SSH and backup IDs, restore destination and snapshot selection behavior, JSON storage concurrency and atomicity, snapshot deletion path security, streaming process outcome resolution, and the synchronization countdown timer.

RsyncUITests · high confidence

The project's Swift Package Manager dependencies have been updated, replacing the previous 'Files' and 'ShellOut' packages with a new set of internal libraries: DecodeEncodeGeneric, ParseRsyncOutput, ProcessCommand, RsyncArguments, RsyncProcessStreaming, RsyncUIDeepLinks, and SSHCreateKey. Additionally, the Package.resolved file has been migrated from format version 1 to version 3.

(dependencies) · high confidence

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

• CAI 52 → 54 (+2.2)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 95 → 92 (-3.4)
• Architecture 95 → 98 (+2.9)
• Maturity 46 → 50 (+3.1)
• Readiness 28 → 34 (+5.9)
• Security 100 → 100 (+0.0)

• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Documentation: no architecture or design documentation (RsyncUITests/README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)

• ConfigurationsTableDataMainView.body (cognitive 17) (RsyncUI/Views/Configurations/ConfigurationsTableDataMainView.swift)
• DetailsView.body (cognitive 19) (RsyncUI/Views/OutputViews/DetailsView.swift)
• Duplicated block (11 lines × 2) (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• Duplicated block (11–12 lines × 2) (RsyncUI/Views/Detailsview/OneTaskDetailsView.swift)
• Duplicated block (13–14 lines × 2) (RsyncUI/Views/Tasks/extensionTasksView.swift)
• Duplicated block (15 lines × 2) (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• Duplicated block (15 lines × 2) (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• Duplicated block (17 lines × 2) (RsyncUI/Views/ScheduleView/CalendarDayView.swift)
• Duplicated block (17–18 lines × 3) (RsyncUI/Views/Configurations/ConfigurationsTableDataView.swift)
• Duplicated block (24 lines × 2) (RsyncUI/Views/ScheduleView/TableofNotExeSchedules.swift)
• Duplicated block (28 lines × 2) (RsyncUI/Views/Configurations/ConfigurationsTableDataView.swift)
• Duplicated block (9 lines × 2) (RsyncUI/Views/InspectorViews/Add/extensionAddTaskView+FormFields.swift)
• Hotspot: RsyncUI/Views/Quicktask/QuicktaskFormView.swift (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• Hotspot: RsyncUI/Views/Restore/RestoreTableView.swift (RsyncUI/Views/Restore/RestoreTableView.swift)
• LogStatsChartView.body (cognitive 32) (RsyncUI/Views/Tasks/LogStatsChartView.swift)
• LogStatsChartView.body (cyclomatic 20) (RsyncUI/Views/Tasks/LogStatsChartView.swift)
• MethodTooLong: QuicktaskFormView.body (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• QuicktaskFormView.body (cognitive 37) (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• QuicktaskFormView.body (cyclomatic 23) (RsyncUI/Views/Quicktask/QuicktaskFormView.swift)
• RestoreTableView.restoretoolbarcontent (cognitive 24) (RsyncUI/Views/Restore/RestoreTableView.swift)
• …and 5 more

• 8 commits — 6 feature/other, 2 fixes

• (repo) — 4 commits
• (root) — 2 commits
• RsyncUI.xcodeproj/project.pbxproj — 1 commit
• RsyncUI/Model — 1 commit

• fix: fix error logging issue
• fix: fix error logging issue
• change: Merge branch 'version-3.0.5'
• change: Merge branch 'version-3.0.5' into version-3.0.6
• change: Merge branch 'version-3.0.6'
• change: Merge pull request #184 from rsyncOSX/version-3.0.5
• change: update
• change: update readme

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

rsyncOSX/RsyncUI 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.