* feat (Connection Statistics): Restored the server connection statistics feature
* perf(store): Optimize data storage performance and implement caching mechanisms
- Implement caching mechanisms in SnippetStore and ServerStore to reduce redundant loading
- Refactor ConnectionStatsStore to use indexes and optimize query performance
- Adopt a more efficient approach when cleaning up expired records
- Add a maximum record limit to prevent data bloat
* perf(store): Optimize data storage performance and add a caching mechanism
Add a caching mechanism to PrivateKeyStore to reduce redundant loading
Make the cleanup and index rebuilding of ConnectionStatsStore asynchronous
Add database compression and size statistics
Display database size in the interface and optimize compression operations
* fix (Cache): Fixed cache invalidation and join statistics issues
- Added a cache invalidation call to the reload method
- Fixed an error in the calculation of join statistics timestamps
- Optimized the cache index rebuild logic
- Added tooltips and click effects for join statistics
* refactor(connection_stats): Convert file operations from synchronous to asynchronous and optimize record cleanup logic
Convert the database size retrieval method from synchronous to asynchronous to prevent UI blocking
Optimize server record cleanup logic by directly deleting redundant records instead of rebuilding indexes
* fix(connection_stats): Fixed an initialization issue when the index database is empty
During Stores initialization, the code now checks whether `connectionStats.indexDbKeys` is empty; if so, it calls `rebuildIndexAndCompact` to rebuild and compact the database. Additionally, the implementation of the `_pruneExcessRecords` method has been optimized to use tuples instead of temporary lists, thereby improving performance. A `mounted` check has been added at the UI layer to prevent state update issues during asynchronous operations.
* fix(server): Improved error string matching logic to more accurately identify connection issues
Error strings are now uniformly converted to lowercase for comparison, and matching criteria have been expanded to cover a wider range of error scenarios, including timeouts, authentication failures, and network errors
* fix(PrivateKeyStore): Fixed an issue where the cache state was not updated when clearing the cache
When clearing the private key store, ensure that the internal cache state is updated simultaneously to maintain consistency
* refactor(store): Add close methods and clean up subscription logic
Add close methods to PrivateKeyStore, SnippetStore, and ServerStore to unsubscribe
Unify cache cleanup logic to prevent memory leaks
* fix(store): Add a cache update suppression mechanism to prevent circular updates
Add an _suppressWatch flag to multiple Store classes to suppress cache invalidation during internal operations
Add a _putWithoutInvalidatingCache method to prevent recursive watchers from being triggered during data updates
* refactor(store): Improve caching and state management using try-finally
In PrivateKeyStore, ServerStore, and SnippetStore:
1. Remove redundant close methods
2. Use try-finally to ensure the _suppressWatch state is reset correctly
3. Optimize cache invalidation logic
4. Standardize transaction handling for update operations
* refactor(store): Optimize data storage operations and fix potential issues
- Ensure the safety and consistency of list operations in ConnectionStatsStore
- Replace direct calls to `box.put` with the `set` method in SnippetStore and ServerStore
- Extract decoding logic for PrivateKeyStore into a separate method
- Add logic to update server-hopping relationships
* fix: Fixed an issue where asynchronous operations were not being waited on and optimized storage operations
Fixed several issues where asynchronous operations were not being waited on to ensure data consistency
Added the _suppressWatch control to ServerStore and PrivateKeyStore
Optimized index management in ConnectionStatsStore to maintain record order
Added a new GitHub participant
* fix: Fixed potential state issues and memory leaks in asynchronous operations
Fixed potential state issues that could occur on the server edit page after a delete operation; added a mounted check
Changed the statistics clearing operation in connection_stats to run asynchronously
Optimized asynchronous operations in PrivateKeyStore and fixed potential memory leaks
* refactor(store): Convert asynchronous methods to synchronous ones to simplify the code
Fixed an issue where asynchronous operations were not handled correctly on the connection statistics page
* fix: Added mounted check and error handling for connection logs
Added a mounted check in _ConnectionStatsPageState to prevent the state from being updated after the component is unmounted
Added a try-catch block for connection logs in ServerNotifier to catch and log potential storage exceptions
* feat: Added Port Forwarding Functionality
Implemented port forwarding functionality, including the following major changes:
- Added a port forwarding configuration model and related state management
- Added a port forwarding page and interaction logic
- Implemented forwarding connections between local and remote ports
- Integrated into the server features menu
- Added necessary Hive adapters and storage support
- Updated plugin configurations across all platforms to support the new feature
* feat (Port Forwarding): Added multilingual support and optimized implementation
Added multilingual support for the port forwarding feature, including Chinese, English, and other languages
Optimized the port forwarding implementation by adding connection management and error handling
Fixed an issue with state persistence when updating port forwarding configurations
Updated related dependencies and submodules
* fix(port_forward): Fixed port forwarding error handling and redesigned the configuration dialog
Handled uncaught errors when port forwarding is disabled or during connection attempts
Extracted the configuration dialog into a standalone component and added port range validation
* fix(port_forward): Fixed issues with port forwarding connection management and UI layout
Fixed an issue where port forwarding connections were not closed properly; now uses `clientGetter` to delay the retrieval of `SSHClient`
Added cleanup logic when connections are closed to prevent memory leaks
Added a `mounted` check in `PortForwardPage` to prevent operations from executing after the component is unmounted
Wrapped the configuration dialog content in a `SingleChildScrollView` to prevent content overflow
* fix(port_forward): Fixed a concurrent modification exception that occurred when closing a port forwarding connection
Fixed a concurrent modification exception that could occur when closing a local forwarding entry by copying the connection list to prevent modifications to the collection during iteration. Also improved the UI by using theme colors and added error handling for configuration saving.
* fix(port_forward_provider): Fixed an issue where entries were not properly removed when port forwarding was stopped
When port forwarding is stopped, ensure that the corresponding entries are removed from the _forwards map. Additionally, before adding a new forwarding rule, check for and close any existing forwarding rules with the same ID to prevent resource leaks.
* refactor(l1n): Remove unused localization and remote host port translations
* fix(port_forward_provider): Handle errors when closing port forwarding
Add error handling to prevent the program from crashing due to exceptions when closing port forwarding
* refactor(port_forward): Refactor port forwarding state management to use serverId
Directly link port forwarding state management to the server ID to simplify parameter passing
Remove direct dependencies on Spi and use serverId as the core identifier instead
Update relevant providers and page logic to accommodate the new state structure
* fix(port_forward): Fixed a race condition issue in port forwarding operations
Added an _inFlight collection to prevent duplicate operations
Added a _saving state when saving configurations to prevent duplicate submissions
Automatically cleans up forwarding when changes in server connection status are detected
* refactor(port_forward_provider): Remove unnecessary concurrency control logic
Simplify the `toggleForward` method by removing concurrency control for the `_inFlight` collection, as it is not required in the current scenario
