wanghongenpin/proxypin

ProxyPin is a cross-platform network debugging and proxy tool that intercepts, inspects, and manipulates HTTP/HTTPS, WebSocket, and other network traffic across mobile and desktop environments. It features a robust proxy engine with advanced capabilities such as SSL interception, request rewriting, breakpoint debugging, and weak network simulation, alongside native VPN integration for Android and iOS. The application provides a comprehensive UI for managing traffic history, favorites, and complex rule sets, while also offering developer utilities like a JavaScript runtime, encryption tools, and AI-assisted inspection via the Model Context Protocol.

42 changes.

The project was rebranded to ProxyPin and significantly expanded its platform support by introducing native VPN capabilities for Android and iOS alongside enhanced desktop features. This period focused on rebuilding the core network engine to support modern protocols like HTTP/2 and WebSocket, while integrating AI debugging tools via the Model Context Protocol.

29 changes.

This period focused on expanding ProxyPin's capabilities across desktop and mobile platforms, introducing comprehensive UI configurations, navigation structures, and platform-specific features like iOS VPN and Windows installers. Significant architectural improvements included a new asynchronous network channel system, enhanced HTTP parsing, and dedicated handlers for WebSocket and SSE protocols. The release also added extensive developer tools, multi-language support, and robust certificate management utilities to improve usability and reliability.

The proxy now supports forwarding HTTP/2 traffic. This change introduces a new HTTP/2 codec and HPACK header compression implementation within the network layer, enabling the proxy to handle HTTP/2 frames, settings, and stream management for both requests and responses.

lib/network/http/h2 · high confidence

The iOS app now includes a new Packet Tunnel extension (ProxyPin) that enables IP-layer VPN proxying. This extension configures network settings to route traffic through a specified proxy host and port, supports an optional list of domains to bypass the proxy (proxyPassDomains), and applies specific IPv4 routing rules (including excluded routes for local and link-local addresses) when IP proxy mode is enabled. It also declares the necessary entitlements for Network Extension and VPN access.

ios/ProxyPin · high confidence

A new \assets/js/fetch.js\ file has been added to provide a \fetch\ API polyfill using \XMLHttpRequest\. This implementation supports standard request options including headers (both object and iterable formats), credentials, and method specification, and exposes a response object with \ok\, \status\, \text\, \json\, and \blob\ methods. This allows code relying on the modern Fetch API to function in environments that do not natively support it.

assets/js · high confidence

The iOS project now includes the standard Flutter framework configuration files, specifically AppFrameworkInfo.plist, Debug.xcconfig, and Release.xcconfig, alongside the Xcode workspace settings. These additions establish the necessary build environment and metadata for the Flutter engine within the iOS application.

ios/Flutter · high confidence

The application now supports multiple languages, including English, Spanish, Indonesian, Portuguese, Thai, Vietnamese, and Chinese. This change introduces the necessary localization files and generated Dart code to enable users to switch the interface language via the settings menu.

lib/l10n · high confidence

The Android app now includes new Kotlin classes for constructing and parsing IPv4 and UDP headers (IP4Header, UDPHeader) along with factory methods to build response packets, and utility helpers for checksum calculation and IP address conversion. A SimpleCache class is also added to manage time-expired entries. These changes provide the underlying network packet manipulation capabilities required for the VPN transport layer on Android.

app · high confidence

The Android app now includes a native VPN service (ProxyVpnService) that intercepts traffic and routes it through a proxy, supporting allow/disallow app lists and domain bypass rules. It also introduces Picture-in-Picture mode for the app interface, allowing users to keep the VPN status visible while using other apps, and adds plugins to retrieve installed app lists (with optional system app inclusion and icons) for granular traffic control.

android/app/src · high confidence

The application introduces a new \AppConfiguration\ singleton in \lib/ui/configuration.dart\ to manage user preferences and UI state. This change enables support for multiple theme colors (mapped via a new \ColorMapping\ class), allows users to toggle between table and text display modes for HTTP headers, and adds settings for Picture-in-Picture (PiP) windows, auto-read of captured records, and confirmation dialogs before clearing data. It also integrates configuration for the in-app MCP server (including redaction and token settings), desktop window positioning, and system tray minimization, while persisting these settings to a local JSON file.

lib/ui · high confidence

The desktop SSL settings now include a new certificate installer and checker that automatically detects whether the ProxyPin root CA is installed and trusted on the system. On macOS, it uses the security CLI to add the certificate to the login keychain as a trusted root; on Windows, it uses certutil to add it to the user's Root store; and on Linux, it copies the certificate to /usr/local/share/ca-certificates/ and runs update-ca-certificates. A dialog prompts users to install the certificate when SSL and system proxy are enabled and the certificate is not yet installed, with an option to skip future prompts. The UI also supports manual installation instructions per platform, importing and exporting CA certificates (including PKCS\#12 with password protection), generating and resetting the root CA, and installing certificates for iOS and Android via the local IP.

lib/ui/desktop/ssl · high confidence

This change introduces the core desktop user interface structure and settings management. It adds the main desktop home page layout, which includes a request list, favorites, history, and toolbox navigation, along with a network tab for viewing request details. A new preferences dialog allows users to configure language, theme (including Material 3 support), theme colors, minimize-to-tray behavior, auto-start, and memory cleanup thresholds. Additionally, it implements window state persistence by listening to resize and move events to save the window's position and size.

lib/ui/desktop · high confidence

The desktop UI now includes a new settings dialog for managing keyword highlighting, allowing users to customize highlight colors and persist their choices via a new \DesktopKeywordHighlight\ widget. Additionally, a new \WindowsToolbar\ widget has been added to provide native-style window management controls (minimize, maximize/restore, close) and a draggable title area for the desktop application.

lib/ui/desktop/widgets · high confidence

The desktop request view now supports HTTP breakpoint interception, allowing you to pause and modify requests or responses in a dedicated editor window before they are sent or received. Additionally, the request replay feature has been expanded with a custom repeat dialog that lets you configure fixed or random intervals, delays, and scheduled execution times, while the request list UI now includes a search bar and a multi-select action bar for batch operations like export and deletion.

lib/ui/desktop/request · high confidence

The HTTP networking layer has been significantly upgraded to support modern protocols and improved data handling. The engine now natively supports HTTP/2 (including h2c prior-knowledge and stream dependency handling) and WebSocket, with dedicated decoders for WebSocket frames and Server-Sent Events (SSE). Content type detection has been expanded to include video and SSE, and body decoding now supports additional compression algorithms like zstd and brotli. The HTTP client implementation has been refactored to handle proxy authentication, bare domain URIs, and large body streaming, while header handling now supports multi-value headers and preserves original casing.

lib/network/http · high confidence

Added the Inno Setup script template and build configuration to generate a Windows installer for ProxyPin. The installer supports English and Simplified Chinese, creates desktop and start-menu shortcuts, and installs the application to the Program Files directory.

windows/packaging/exe · high confidence

The certificate handling module has been expanded with new classes to support detailed X.509 certificate inspection and PKCS12 bundle creation. Users can now parse PEM certificates into structured data including subject/issuer details, validity periods, and various thumbprints (SHA-1, SHA-256, MD5). The module also supports extracting raw ASN.1 bytes of the Subject Distinguished Name to ensure strict issuer matching across different platforms, and provides functionality to generate PKCS12 files with configurable encryption algorithms and passwords.

lib/network/util/cert · high confidence

Users on Windows and macOS can now receive and install updates directly within the application. The new \app\_update\ module checks for the latest version via the GitHub Releases API, offering a dialog to ignore specific releases. On desktop, selecting 'Update Now' triggers an in-app download with progress tracking, background download support, and platform-specific installation logic: Windows uses a zip-based in-place update with UAC elevation handling, while macOS extracts the .app bundle and replaces it after the app quits. A GitHub download mirror is automatically used for Chinese locale users to improve download reliability.

_lib/ui/app\update · high confidence

This change adds a comprehensive set of utility classes to the \lib/network/util\ directory to support the proxy application's core functionality. It introduces \ByteBuf\ and \byte\_utils\ for efficient binary data handling, \compress\ for decoding gzip, brotli, zstd, and zlib content, and \crts\ (CertificateManager) for generating and caching SSL/TLS certificates, including support for extracting raw ASN.1 bytes for accurate issuer matching. It also adds \idna\ for normalizing non-ASCII hostnames to punycode, \process\_info\ and \process\_info\_macos\ for resolving process details via FFI on macOS (avoiding fork-related deadlocks) and other platforms, and \cache\ implementations (\ExpiringCache\, \LruCache\) for managing request and certificate state. Additional utilities include \crypto\ for hashing and key management, \file\_read\ for platform-specific file access, and \localizations\ for language detection.

lib/network/util · high confidence

The application now supports saving and managing request history and favorites locally. Users can view, add, remove, and rename history items and favorites. Favorites and history entries can be exported to and imported from JSON or HAR files, with automatic deduplication during import. Favorites also support WebSocket message persistence with size limits to control storage usage.

lib/storage · high confidence

This change introduces the primary mobile application entry point (lib/ui/mobile/mobile.dart), establishing the foundational UI structure for the mobile client. It implements the main home page state, integrating the proxy server lifecycle with the request list view, and sets up core navigation components including a bottom navigation bar, drawer menu, and search functionality. The file also wires up critical mobile-specific features such as Picture-in-Picture (PiP) support, remote device history synchronization, and an in-app MCP (Model Context Protocol) service for AI-assisted inspection, while managing memory cleanup and multi-select controllers for the request list.

lib/ui/mobile · high confidence

Users can now perform file operations (read, write, create, delete, etc.) and compute MD5 hashes directly within JavaScript scripts via the new File API and md5() function. To support these capabilities and improve concurrency, the system introduces a JavaScript runtime pool that manages engine instances, allowing scripts to run more efficiently with better resource management.

lib/network/components/js · high confidence

The mobile interface now includes dedicated pages for managing request history, favorites, and domain-based views, along with support for custom request replay and breakpoint execution. Users can import and export favorites and history data, search and filter requests by domain or keyword, and pause requests or responses for inspection and modification via the new breakpoint executor. The request list supports multi-select, highlighting, and auto-read tracking, while the editor allows editing requests and viewing responses directly from these contexts.

lib/ui/mobile/request · high confidence

This change introduces the native integration layer (lib/native) that connects the Flutter app to platform-specific capabilities. It adds support for Picture-in-Picture mode, allowing the proxy to run in a small window, and implements app whitelisting/blacklisting logic to control which applications are proxied. The VPN module now supports system proxy configuration, proxy pass domains, and IP-layer proxying. Additionally, it provides methods to detect installed apps (with optional icons and system app inclusion), check iOS certificate installation status, and retrieve process information by port.

lib/native · high confidence

The \lib/ui/component/json\ directory now includes new \JsonViewer\ and \JsonText\ widgets, along with supporting \theme.dart\ and \toast.dart\ files. These components provide a structured tree view and a raw text view for JSON data, featuring syntax highlighting, dark mode support via \ColorTheme\, and integrated search capabilities that highlight matches and auto-scroll to the current result. The implementation handles large JSON documents by chunking text for performance and supports double-clicking to copy values.

lib/ui/component/json · high confidence

The desktop settings interface now includes dedicated pages for managing environment variables, local hosts, request blocking, request breakpoints, request crypto rules, and request mapping. These new UI components allow users to configure and persist settings for these features directly from the desktop application, with support for importing and exporting configurations where applicable.

lib/ui/desktop/setting · high confidence

The desktop toolbar now includes an environment switcher that lets users select and manage active network environments directly from the top bar, a new MCP (Model Context Protocol) service panel for configuring and connecting AI assistants like Claude Code and Cursor to inspect traffic, and a phone connect dialog that generates a QR code for quick mobile device connection. Additionally, a weak network indicator is now visible in the toolbar when network throttling rules are active, providing immediate visual feedback and access to network condition settings.

lib/ui/desktop/toolbar · high confidence

The application now includes desktop-specific utilities for managing the main window lifecycle and system integration. DesktopSupport validates saved window positions and sizes to prevent the window from appearing off-screen or with invalid dimensions, centering the window if the stored position is no longer visible. Additionally, DesktopTrayManager implements a system tray icon with a context menu, allowing users to minimize the application to the tray and restore the window or quit the app directly from the tray icon.

lib/utils · high confidence

The Toolbox now includes several new pages for developers: an AES encryption/decryption tool, a certificate hash viewer, a multi-format encoder (URL, Base64, Unicode, MD5), a JavaScript runner with a CodeForge editor, a JSON viewer with formatting and tree view, a QR code generator and scanner, a regular expression tester with replacement, a text diff tool with line highlighting, and a multi-language text editor with syntax highlighting.

lib/ui/toolbox · high confidence

The iOS VPN module now includes a new IP-layer proxy implementation that intercepts raw IPv4 packets (TCP, UDP, and ICMP) at the tunnel level. This engine manages persistent connections via ConnectionManager, routing traffic either directly to destination endpoints or through a configured proxy address based on port and IP type. It also integrates a ping utility (GBPing) for network reachability checks.

ios/ProxyPin/vpn · high confidence

This change introduces five new mobile widget files in lib/ui/mobile/widgets. The About screen now includes links to GitHub, feedback, version checks, downloads, privacy policy, and sponsor/donate options (Afdian, Buy Me a Coffee). A new FloatingWindow widget and manager enable draggable overlay windows. KeywordHighlight provides a UI to enable/disable and configure per-color keyword highlighting with persistence. PictureInPictureWindow and PictureInPictureIcon add a draggable PiP icon and a compact list view of HTTP requests, integrating with the proxy server and app whitelist/blacklist. RemoteDevicePage adds a UI for managing remote device connections via QR code scanning, manual IP input, and a persistent device list.

lib/ui/mobile/widgets · high confidence

Added a new bottom navigation configuration page, a side drawer menu, and an overflow menu for mobile devices. These components provide direct access to key features including favorites, history, hosts, request blocking, request rewriting, request mapping, request crypto, scripts, breakpoints, weak network management, environment variables, and the MCP service. The weak network tile includes a visual indicator when network conditions are actively restricted.

lib/ui/mobile/menu · high confidence

Users can now edit request mapping rules directly on mobile devices through two new editor screens. The local editor allows configuring response status codes, headers, and bodies (including text or file-based replacements) via a tabbed interface with localization support. The script editor provides a code editing experience using CodeForge with JavaScript syntax highlighting and a Monokai theme, enabling users to write custom request handling scripts.

_lib/ui/mobile/setting/request\map · high confidence

This change introduces a suite of new mobile-specific settings pages in the app's settings section. Users can now manage an app whitelist/blacklist to control which applications are captured, configure environment variables with dynamic support, and manage local hosts mappings. Additionally, the update adds pages for configuring domain filters, setting up external proxy servers with authentication, managing report servers, and enabling an in-app MCP server for AI assistant integration. General preferences have also been updated to include options for memory cleanup thresholds, theme colors, and bottom navigation.

lib/ui/mobile/setting · high confidence

Added a suite of new network interceptor components in lib/network/components that enable advanced traffic manipulation. The Hosts interceptor allows domain-to-IP mapping to override DNS resolution. Request Breakpoints pause requests and responses for manual inspection and modification via a UI executor, supporting environment variable rendering in headers and bodies. Request Rewrites and Maps allow replacing or updating request/response lines, headers, and bodies using regex matching, wildcards, or JavaScript scripts. A Request Block interceptor enables blocking specific requests or responses by URL pattern. Additionally, a Network Condition interceptor simulates weak networks by injecting latency, packet loss, and bandwidth throttling, while a Report Server interceptor sends traffic logs to external servers in HAR format with optional gzip compression.

lib/network/components · high confidence

Added new manager classes in the network component layer to handle configuration and logic for environments (with variable rendering), hosts (domain mapping), request blocking, request breakpoints, request rewriting, request mapping, request crypto, weak network simulation, and report servers. These managers provide persistent storage, rule matching, and configuration management for these network features.

lib/network/components/manager · high confidence

The application now uses a dedicated detail panel (lib/ui/content) to display HTTP request and response information. This panel includes a new HeadersWidget that allows users to toggle between table and raw text views and copy headers directly. It also introduces a Websocket widget for viewing WebSocket messages in a chat-style interface with preview and download capabilities. The panel dynamically updates tabs based on content type, adding 'WebSocket' or 'SSE' tabs when applicable, and integrates with the existing menu system for sharing and exporting requests.

lib/ui/content · high confidence

The desktop settings now include new UI components for editing rewrite rules: \DesktopRewriteReplace\ allows users to modify request/response lines, headers, and bodies via a tabbed interface, while \DesktopRewriteUpdate\ provides a dialog-based interface for adding and configuring individual update rules. These components integrate \CodeForge\ for code editing and \re\_highlight\ for syntax highlighting, and explicitly support regex matching in rule configurations.

lib/ui/desktop/setting/rewrite · high confidence

A new SearchModel class has been introduced in the UI component layer to power the application's search functionality. This model enables users to filter network traffic using a combination of text keywords (with optional case sensitivity and regular expression support), HTTP method, request/response content types, status code ranges, and response duration thresholds. It also supports filtering by specific protocols (HTTP, HTTPS, WebSocket, SSE) and allows users to define which parts of the request/response data are included in the keyword search.

lib/ui/component/model · high confidence

The \lib/ui/component\ directory now includes a suite of new shared widgets: \AppAlertDialog\ and \CustomToast\ for standardized error and status notifications; \ContextMenuItem\ and \showCustomContextMenu\ to replace the crashing third-party context menu plugin with a native Flutter implementation; \ContextMenuRegion\ for gesture-based menu triggering; \DomainAddDialog\ as a shared dialog for host filtering; \EnvHighlightTextEditingController\ and \buildEnvHighlightText\ to visually highlight environment variable references (\{{name}}\) in the request editor; \MultiSelectController\ to manage multi-selection state across lists; and \MultiWindow\/\MultiWindowCompat\ to handle window creation, routing, and method invocation for the desktop multi-window feature. Additionally, \ProxyPortSetting\ validates port input ranges, \MethodPopupMenu\ provides colored HTTP method selection, and \SearchConditions\ adds advanced search capabilities with regex and content-type filtering.

lib/ui/component · high confidence

The application has been rebranded from 'network' to 'ProxyPin', with updated documentation (README, README\_CN) and an Apache 2.0 license. A new in-app MCP (Model Context Protocol) server has been introduced, allowing AI assistants to inspect, search, and manipulate captured HTTP(S) traffic via a stdio interface, supported by detailed integration documentation (AGENTS.md, SKILL.md). The project also adds distribution packaging configurations for Windows (MSIX, EXE, ZIP) and macOS (DMG), and updates the Flutter framework revision.

(repo-wide) · high confidence

A new QR code scanner component has been introduced, allowing users to scan QR codes via the device camera or by selecting an image file. The implementation handles camera permission requests with a localized dialog and provides a scanning interface with flashlight toggle and visual feedback.

lib/ui/component/qrcode · high confidence

The SOCKS5 implementation in lib/network/socks now supports connecting to proxy destinations specified by domain names and IPv6 addresses, in addition to the previously supported IPv4 format. This allows users to route traffic through SOCKS5 proxies when the target host is identified by a hostname or an IPv6 address, expanding compatibility with modern network configurations.

lib/network/socks · high confidence

The iOS app now supports Picture-in-Picture (PiP) mode for video playback. When PiP is active, a SwiftUI-based overlay is displayed within the floating window, showing a scrollable log of data and two action buttons: one to toggle the VPN connection (connect/disconnect) and another to clear the session data. This feature is implemented via a new Flutter plugin (\PictureInPictureManager\) that handles the AVKit integration and communicates with the main app via method channels.

ios/Runner/pip · high confidence

The iOS app now includes a native iOS runner (AppDelegate, SceneDelegate, VpnManager) that enables background packet capture and Picture-in-Picture (PiP) support. The app uses a VPN tunnel provider to capture network traffic, with a background audio workaround to keep the VPN active when the app is in the background. The app also supports PiP mode, allowing users to continue using the app while watching videos in PiP mode.

ios/Runner · high confidence

The iOS app now exposes native capabilities to verify if a CA certificate is installed and to evaluate the trust of a certificate chain, as well as to check if local network access (Wi-Fi or Ethernet) is available. These features are implemented in the new MethodHandler, which registers a Flutter method channel to allow the Dart layer to request local network status and perform certificate validation against the iOS security framework.

ios/Runner/Handlers · high confidence

The iOS project structure has been established, introducing native capabilities for a VPN proxy extension (ProxyPin.appex) using the NetworkExtension framework, as well as Picture-in-Picture functionality. The configuration includes the necessary Swift source files for packet handling, connection management, and tunnel providers, alongside the required entitlements and build phases to embed the extension.

ios/Runner.xcodeproj · high confidence

The macOS build now integrates several new platform plugins that enable advanced desktop features. Users can now minimize the application to the system tray, open multiple independent windows, and share content directly from the app. Additionally, the app can now detect device information, manage file picking, launch external URLs, and retrieve screen details, providing a more integrated experience with the macOS operating system.

macos/Flutter · high confidence

The \lib/network\ directory has been completely removed, deleting the \channel.dart\, \compress.dart\, and \handler.dart\ files that previously handled low-level socket connections, HTTP decoding/encoding, and request forwarding. This indicates a significant architectural shift away from the custom network stack used for the proxy functionality.

lib/network · high confidence

A new ProGuard configuration file has been introduced to the Android application to preserve specific classes during the build process. The rules ensure that core Flutter framework classes (io.flutter.\) and internal application classes (de.prosiebensat1digital.\) are kept intact, preventing obfuscation issues that could break functionality. Additionally, warnings related to the Google Play Core library are suppressed to streamline the build output.

android/app · high confidence

The app now includes localized strings for iOS permission requests in English and Simplified Chinese. Specifically, InfoPlist.strings files define usage descriptions for the camera (to scan QR codes) and the photo library (to access and save images), ensuring the system prompts users with clear explanations when these permissions are requested.

ios/Runner/en.lproj, ios/Runner/zh-Hans.lproj · high confidence

The application entry point has been rewritten to replace the default Flutter demo template with a production-ready startup sequence. It now supports an in-app MCP server via a dedicated \--mcp-stdio\ argument for AI assistant integration, initializes Rust FFI libraries with graceful degradation on older iOS versions, and routes execution to specific home pages based on the platform (Mobile, Desktop, or Multi-Window). The app also preloads environment variables to optimize initial request performance and integrates the CodeForge library for enhanced code editing capabilities.

lib · high confidence

The macOS application has been renamed from 'network' to 'ProxyPin', which updates the window title and app display name. The bundle identifier has changed from 'com.network.network' to 'com.proxy.pin', and the copyright notice now attributes ownership to Hongen Wang instead of the previous generic entity.

macos/Runner/Configs · high confidence

On desktop platforms, closing the main application window now minimizes the app to the system tray rather than exiting immediately. The first time this occurs, a dialog prompts the user to confirm whether to minimize to the tray or exit, and this preference is saved for future sessions. This behavior is controlled by the 'minimizeToTray' configuration setting and includes fallback logic to ensure the app exits cleanly if tray operations fail.

lib/ui/launch · high confidence

The HTTP parser now correctly handles \Transfer-Encoding: chunked\ responses by introducing a new incremental \ChunkedDecoder\ and \BodyReader\, ensuring that chunked payloads are fully decoded even when split across TCP packets. Additionally, it fixes a bug where responses lacking both \Content-Length\ and \Transfer-Encoding\ headers (close-delimited responses) were previously dropped; these are now correctly forwarded to preserve the connection close signal, preventing client-side timeouts. The parser also explicitly bypasses body processing for \video/x-flv\ and \text/event-stream\ content types to allow direct forwarding.

lib/network/http/parse · high confidence

The search component now includes a new, draggable Find/Replace overlay (FindPanelView) that supports case sensitivity, whole-word matching, and regular expressions, with automatic positioning adjustments to avoid keyboard obstruction on mobile. Under the hood, text rendering uses a new HighlightTextDocument and HighlightTextWidget that apply syntax highlighting via the re\_highlight library (using Atom One Light/Dark themes) and integrate search match highlighting. For large texts, a VirtualizedHighlightText widget chunks and virtualizes the rendered lines to maintain performance, while the SearchTextController manages match navigation and state.

lib/ui/component/search · high confidence

The proxy engine now uses a new channel-based architecture in \lib/network/channel\ to manage network connections. This change introduces a \Channel\ class for handling socket I/O, a \ChannelContext\ for tracking connection state and HTTP/2 stream dependencies, and a \ChannelDispatcher\ to route events through handlers. This new structure supports improved HTTP/2 stream ordering, large body streaming, and more robust connection lifecycle management, replacing the previous synchronous or less structured connection handling.

lib/network/channel · high confidence

The Linux desktop application now supports system tray management, window minimization, and multi-window operations, allowing users to manage the app icon in the system tray and open multiple editor windows. It also introduces HTTP proxy configuration capabilities, JS script execution support, and zstd compression for request history, enhancing both usability and data handling on Linux.

linux/flutter · high confidence

The Linux build process and application identity have been updated to reflect the new 'ProxyPin' branding. The binary name and application ID were changed from 'network' to 'ProxyPin' (com.network.proxy), and the window title and desktop entry now display 'ProxyPin'. A new build script (build.sh) was added to generate a .deb package, and the application icon is now correctly set in both debug and release modes. Additionally, the desktop multi-window plugin is now registered to support multiple windows.

linux · high confidence

The mobile request rewrite interface has been updated to allow users to apply regular expression matching to rewrite rules, with the \useRegex\ flag enabled by default in the update editor. Additionally, the replace body editor now supports selecting external files for request and response body modifications, moving beyond simple text input. These changes enhance the flexibility of mobile request rewriting by enabling pattern-based matching and file content substitution.

lib/ui/mobile/setting/rewrite · high confidence

The proxy now uses specialized channel handlers to improve protocol support and reliability. WebSocket traffic is handled by WebSocketChannelHandler, which drains the decoder in a loop to ensure all frames arriving in a single TCP read are captured and delivered. Server-Sent Events (SSE) are processed by SseChannelHandler, which strips chunked transfer-encoding framing before decoding events, ensuring correct parsing while forwarding raw bytes verbatim. HTTP proxy requests are managed by HttpProxyChannelHandler, which integrates interceptors, request rewriting, and specific error handling for connection failures (returning rewritten 502 responses when rules exist). A new RelayHandler provides simple bidirectional forwarding for established connections.

lib/network/handle · high confidence

The desktop application now features a new left-side navigation rail that allows users to switch between Requests, Favorites, History, and Toolbox views. This change introduces dedicated UI components for Favorites (supporting copy, delete, and WebSocket indicators) and History (supporting session saving, HAR import, and cache time configuration), replacing the previous navigation structure.

_lib/ui/desktop/left\menus · high confidence

The proxy server in lib/network/bin has been refactored to read settings from a persistent configuration file (config.cnf) instead of using hardcoded values. Users can now control options such as the listening port (default 9099), SSL interception, system proxy integration, SOCKS5, HTTP/2, and app whitelists/blacklists via this configuration. The server also supports a pluggable interceptor chain (including hosts, request rewriting, scripting, blocking, breakpoints, and network condition simulation) and event listeners, allowing for more flexible traffic manipulation and monitoring.

lib/network/bin · high confidence

The bundled Certificate Authority (CA) certificate has been rotated to a new identity (ProxyPin CA) with a renewed validity period, and the previously encrypted RSA private key (ca.key) has been removed and replaced by a new unencrypted private key file (ca\_key.pem). This change updates the trust anchor used for HTTP proxy operations, requiring users to trust the new CA certificate to avoid security warnings when connecting through the proxy.

assets/certs · high confidence

The Xcode build scheme for the macOS Runner project has been updated to target the 'ProxyPin.app' executable instead of the previous 'network.app'. The scheme is now configured for Xcode version 15.10 and includes a pre-action script to prepare the Flutter framework during the build process. Additionally, GPU validation mode has been enabled in the debug configuration to assist with graphics debugging.

macos/Runner.xcodeproj/xcshareddata · high confidence

The Windows build configuration has been updated to support a broader set of platform-specific features. The CMake build system now uses a configurable target platform (defaulting to windows-x64) instead of a hardcoded value, allowing for easier cross-compilation or future platform support. Additionally, the Flutter plugin registrant has been expanded to include registrations for desktop multi-window, JavaScript execution, permission handling, system proxy management, screen retrieval, sharing, tray management, URL launching, audio, window management, and Zstandard compression, enabling these capabilities within the Windows application.

windows/flutter · high confidence

The Windows runner now includes a crash handler that intercepts unhandled exceptions, generates minidumps, and displays an error dialog before terminating. On session end, the application automatically clears the system proxy settings to prevent lingering configurations. The main window title and default size have been updated to 'ProxyPin' (980x680), and the project metadata (company name, file description, copyright) has been updated to reflect the new product identity. Additionally, the multi-window plugin callback is now registered to ensure proper plugin initialization for child windows.

windows/runner · high confidence

The macOS app no longer quits when the last window is closed, instead remaining active in the menu bar to support tray functionality. The main window now features custom-positioned traffic-light buttons (close, minimize, zoom) that update dynamically during resizing and full-screen transitions, and it hides briefly at launch to prevent a visual flash. A new AppLifecycleChannel bridges app termination events to the Flutter layer. Entitlements have been expanded to include network client/server access, JIT execution, scripting targets, and user-selected file read-write permissions, while the app category is set to Utilities.

macos/Runner · high confidence

The macOS application bundle has been renamed from 'network.app' to 'ProxyPin.app', updating the product name in the Xcode project. The project configuration has been upgraded to Xcode 15.1 (LastUpgradeCheck 1510) and includes migration adjustments for Swift 14.2. CocoaPods integration is now fully configured, adding the Pods framework, test frameworks, and associated build phases (such as embedding pods and checking the manifest lock) to both the main Runner and RunnerTests targets. Additionally, new source files including AppLifecycleChannel.swift, T.m, and a RunnerProfile.entitlements have been added to the project structure.

macos/Runner.xcodeproj · high confidence

Added initial iOS test suite structure; Added tests for HTTP proxy core, UI components, and certificate handling.

The Android build system now uses Gradle 8.11.1 for project builds. This change updates the distribution URL in the gradle-wrapper.properties file, ensuring that the build process relies on this specific version of the Gradle build tool.

android/gradle · high confidence

The application has been renamed from 'network' to 'ProxyPin' (version 1.3.2+37), accompanied by a comprehensive update of the Flutter dependency ecosystem. Key changes include migrating the code editor to CodeForge, adding support for Brotli and Zstandard compression, and integrating new libraries for file picking, multi-window support, and system tray management. The Android build configuration was also updated to use AGP 8.9.1 and Kotlin 2.1.0, while iOS and macOS Podfiles were regenerated to align with the new dependency set.

(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 → 55 (+2.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 84 (-12.1)
• Architecture 96 → 96 (-0.1)
• Maturity 55 → 59 (+4.3)
• Readiness 24 → 33 (+9.1)
• Security 95 → 95 (+0.0)

• Boundary-crossing change coupling: host_filter.dart ↔ ssl.dart (lib/network/components/host_filter.dart)
• Change coupling: PacketTunnelProvider.swift ↔ VpnManager.swift (ios/ProxyPin/PacketTunnelProvider.swift)
• Change coupling: desktop.dart ↔ mobile.dart (lib/ui/desktop/desktop.dart)
• Change coupling: http_proxy_handle.dart ↔ body_reader.dart (lib/network/handle/http_proxy_handle.dart)
• Change coupling: http_proxy_handle.dart ↔ codec.dart (lib/network/handle/http_proxy_handle.dart)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Off-boarding risk: anonymized user #1
• Scanner failed to run — not a clean result
• Test reliability not included
• The README lists features but does not state the supported platforms beyond Windows/Mac/Android/iOS/Linux and a brief full-platform line; the 'Support Windows、Mac、Android、IOS、Linux Full platform system' opening is cut by the scanner, so the exact supported OSes are not visible. (README.md)
• complexity unreadable for .dart, .java, .kt, .swift — churn × complexity hotspots could not be measured

• AppUpdateRepository.checkUpdate (cognitive 21) (lib/ui/app_update/app_update_repository.dart)
• CertInstaller.isCertInstalled (cognitive 21) (lib/ui/desktop/ssl/cert_installer.dart)
• Change coupling: channel_dispatcher.dart ↔ h2_codec.dart (lib/network/channel/channel_dispatcher.dart)
• Change coupling: favorite.dart ↔ request.dart (lib/ui/mobile/request/favorite.dart)
• Change coupling: history.dart ↔ history.dart (lib/ui/desktop/left_menus/history.dart)
• Change coupling: rewrite_replace.dart ↔ rewrite_update.dart (lib/ui/mobile/setting/rewrite/rewrite_replace.dart)
• Change coupling: rewrite_update.dart ↔ rewrite_replace.dart (lib/ui/desktop/setting/rewrite/rewrite_update.dart)
• Change coupling: ssl.dart ↔ ssl.dart (lib/ui/desktop/ssl/ssl.dart)
• Change-coupling hub: mobile.dart → desktop.dart, filter.dart, about.dart (lib/ui/mobile/mobile.dart)
• ChannelDispatcher.channelRead (cognitive 60) (lib/network/channel/channel_dispatcher.dart)
• ChannelDispatcher.channelRead (cyclomatic 32) (lib/network/channel/channel_dispatcher.dart)
• ChunkedDecoder.feed (cognitive 53) (lib/network/http/parse/chunked_decoder.dart)
• ChunkedDecoder.feed (cyclomatic 28) (lib/network/http/parse/chunked_decoder.dart)
• ClassTooLong: McpActions (lib/mcp/protocol/mcp_actions.dart)
• ClassTooLong: Pkcs12 (lib/network/util/cert/pkcs12.dart)
• ClassTooLong: X509Utils (lib/network/util/cert/x509.dart)
• ConnectionHandler.handleTCPPacket (cognitive 29) (ios/ProxyPin/vpn/ConnectionHandler.swift)
• ConnectionHandler.handleTCPPacket (cognitive 38) (android/app/src/main/kotlin/com/network/proxy/vpn/ConnectionHandler.kt)
• ConnectionHandler.handleTCPPacket (cyclomatic 18) (ios/ProxyPin/vpn/ConnectionHandler.swift)
• ConnectionHandler.handleTCPPacket (cyclomatic 19) (android/app/src/main/kotlin/com/network/proxy/vpn/ConnectionHandler.kt)
• …and 581 more

• 22 commits — 14 feature/other, 8 fixes

• lib/network — 7 commits
• lib/ui — 5 commits
• lib/l10n — 4 commits
• (repo) — 2 commits
• (root) — 1 commit
• android/app — 1 commit
• lib/mcp — 1 commit
• lib/utils — 1 commit

• fix: Merge pull request #921 from xinchenok/fix/h2c-prior-knowledge
• fix: Merge pull request #942 from MengJunTuan/fix/android-vpn-destination-port
• fix: fix(cert): encode IP hosts as iPAddress SAN to pass strict HostnameVerifier (#913)
• fix: fix(http): relay close-delimited responses instead of dropping the body (#844)
• fix: fix(request): remove stale row refresh callbacks on unmount to prevent memory leak
• fix: fix(vpn): record Android VPN destination port synchronously (#530)
• fix: fix: preserve HTTP/2 stream order and HAR protocol evidence
• fix: fix: support h2c prior-knowledge capture and forwarding
• change: build(deps): migrate to file_picker 13 federated API
• change: feat(desktop): sanitize window size and improve initialization logic
• change: feat(environment): add support for built-in dynamic variables (#900)
• change: feat(headers): support multi-value headers and update header types to dynamic (#901)
• change: feat(idna): add host normalization for non-ASCII domain names (#923)
• change: feat(mcp): add in-app MCP server so AI assistants can inspect
• change: feat(mcp): add in-app MCP server so AI assistants can inspect & debug traffic
• change: feat(panel): add response update mechanism for detail requests (#922)
• change: feat(request): maintain selection state using request ID to handle list item rebuilds (#915)
• change: feat(request-rewrite): add move up and move down actions for rules (#926)
• change: feat(runtime): include Visual C++ runtime libraries for app-local deployment
• change: feat(windows): enhance UAC elevation handling and add shell execution support
• …and 2 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• app

• android

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

wanghongenpin/proxypin 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.