metalbear-co/mirrord
57.8
Adequate · 14 November 2026
243.4k
lines of production code
Rust
primary language
5
measurements over time
What this system is
Features
Add CRI-O container runtime support with OpenShift compatibility
The agent now supports the CRI-O container runtime, enabling mirroring on OpenShift clusters. A new \crio.rs\ module implements the \ContainerRuntime\ interface to communicate with the CRI-O socket, specifically handling a fallback logic to parse container PIDs from the \info\ JSON field when the standard \pid\ key is missing, which addresses observed behavior differences on OpenShift. This is accompanied by a new \error.rs\ module defining specific error types for CRI-O, Docker, and containerd runtime interactions.
mirrord/agent/src/runtime · high confidence
Add Events tab and context-aware API v2 endpoints to the UI server
The UI server now exposes new API v2 endpoints to support an Events tab and context-aware target selection. The \/api/v2/operator/events\ endpoint streams interception events from the operator via Server-Sent Events (SSE), allowing users to monitor live session activity across contexts. Additionally, the \/api/v2/kube/targets\ and \/api/v2/kube/target-types\ endpoints enable the UI to enumerate Kubernetes targets (such as Pods, Deployments, and Jobs) within a specific context and namespace, facilitating the configuration wizard's target picker with real-time cluster data.
mirrord/cli/src/ui/server/v2 · high confidence
Add configuration support for branching ClickHouse, CockroachDB, DynamoDB, Google Spanner, MariaDB, MongoDB, MSSQL, S3, and turbopuffer
The database branching feature now supports branching for ClickHouse, CockroachDB, DynamoDB, Google Spanner, MariaDB, MongoDB, MSSQL, S3, and turbopuffer. Users can configure these branches by setting the \type\ field in their \db\_branches\ configuration to the respective database or service name. Each type includes specific configuration options for connection, copying data (schema and/or data), and authentication, allowing users to create isolated branches for development and testing.
_mirrord/config/src/feature/database\branches · high confidence
Add dedicated connection logic for port-forwarding and TLS-secured external proxy
The internal proxy now includes specific modules for establishing agent connections: \portforward.rs\ handles Kubernetes-based port-forwarding connections, while \tls.rs\ provides a function to wrap raw TCP streams with TLS for external proxy communication. This separates the connection creation logic for these two distinct transport mechanisms.
_mirrord/intproxy/src/agent\conn · high confidence
Added Node.js sample application and Kubernetes deployment manifests
A new Node.js sample application (sample/node/app.mjs) has been added to demonstrate file operations and network server functionality, accompanied by a Kubernetes deployment manifest (sample/kubernetes/app.yaml) that configures the 'py-serv' deployment and NodePort service for running the sample in a cluster environment.
sample · high confidence
Added Rust sample application demonstrating file and network operations
A new Rust sample application has been added to the \sample/rust\ directory. This sample demonstrates basic file I/O operations (reading, writing, seeking) using both standard Rust libraries and unsafe \libc\ calls, as well as establishing a TCP listener to handle incoming network connections. It serves as a reference implementation for interacting with local file systems and network sockets in Rust.
sample/rust · high confidence
Added Windows-specific string utilities and error handling
Introduced the \str-win\ crate to provide safe, efficient utilities for converting between Rust strings and Windows-style null-terminated buffers (UTF-8 and UTF-16), including proper handling of surrogate pairs and multi-string formats. Added a dedicated error module in \layer-lib\ to re-export Windows-specific error types and define console-related errors, supporting the new Windows layer capabilities.
mirrord/str-win · high confidence
Added connection handoff protocol definitions for remote layer
The remote-layer-protocol library now defines the data structures and environment variables required for socket connection handoff between the remote layer and the workload companion. This includes the \ConnectionHandoffRequest\, \ConnectionHandoffResponse\, and \ConnectionHandoffVerdict\ types, along with environment constants for passing socket file descriptors and library paths, enabling the remote layer to delegate accepted connections to the companion agent.
mirrord/remote-layer-protocol · high confidence
Agent iptables logic extracted to a dedicated crate with multi-container support
The iptables management code has been moved into a new \mirrord/agent/iptables\ crate, introducing a modular redirector architecture (Standard, Mesh, Ambient, and FlushConnections) that improves reliability and cleanup. A key behavioral change is the introduction of dynamic iptables chain names (e.g., \MRDIN\_{id}\) via the \MIRRORD\_AGENT\_IPTABLES\_IDENTIFIER\ environment variable, which allows multiple mirrord agents to coexist within the same pod network namespace without rule collisions. The agent now also automatically detects the service mesh vendor (Istio, Linkerd, Kuma) and handles Istio Ambient mode's \route\_localnet\ coordination, while connection flushing now uses \ss -K\ and selectively applies \conntrack -D\ only when necessary.
mirrord/agent/iptables · high confidence
Agent now supports connection handoffs from remote layers and resolves ECS replica IDs
The workload companion now handles incoming TCP connections handed off by an injected remote layer via a Unix seqpacket socket, correctly capturing the original source address from the transferred file descriptor and routing the connection into the existing incoming pipeline. Additionally, the agent can now automatically resolve a unique replica identifier for sessions-manager by detecting the AWS ECS platform and querying its instance metadata endpoint (falling back to a configured environment variable or hostname), enabling proper session management in ECS deployments.
_mirrord/agent/src/workload\companion · high confidence
Agent outgoing traffic now supports Unix stream and seqpacket sockets
The agent's outgoing connection router has been expanded to handle Unix domain sockets in addition to TCP and UDP. New modules (\tcp\_unix.rs\ and \seqpacket.rs\) implement the \ConnectionKind\ trait for \TcpOrUnixConnection\ (covering both TCP and Unix stream sockets) and \SeqpacketConnection\ (covering Unix seqpacket sockets). This allows applications to mirror outgoing traffic to Unix sockets, including pathname-based, abstract, and unnamed addresses, with connection attempts executed in the target's network namespace and subject to the same throttling and timeout policies as existing IP-based connections.
mirrord/agent/src/outgoing · high confidence
Agent utility modules for path resolution, protocol versioning, and I/O handling
The agent now includes dedicated utility modules in \mirrord/agent/src/util\ to support core mirroring operations. \InTargetPathResolver\ handles resolving and normalizing file paths from the target container's perspective, correctly managing symlinks and root prefixes. \ClientProtocolVersion\ provides a shared, thread-safe wrapper for tracking the client's protocol version, defaulting to 1.2.2 for backward compatibility. \RolledBackStream\ enables prepending data buffers to existing I/O streams, which is essential for handling TLS traffic where initial handshake data must be processed before the stream is handed off. Additional utilities include error types for runtime creation and modular I/O helpers for buffering, throttling, and timeouts.
mirrord/agent/src/util · high confidence
Async file read completion delivery via IOCP
The Windows layer now supports asynchronous file reads by posting completion packets directly to the user's IO completion port (IOCP). This change introduces a new \iocp\ module that captures the original \NtSetIoCompletion\ syscall and uses it to deliver read results to the application, allowing the caller's thread to return immediately with \STATUS\_PENDING\ while the OS handles FIFO ordering and signaling. This enables managed file handles to perform non-blocking I/O without hanging the application thread.
mirrord/layer-win/src/iocp · high confidence
Automatic port forwarding for database branches
The internal proxy now automatically establishes and manages port forwards for database branches configured in mirrord.json. This change introduces logic to resolve connection parameters (such as host, port, user, and password) from the target environment, handle connection URL patterns, and apply query parameter overrides (e.g., for SSL modes or IAM authentication) to ensure local connections correctly route to the remote database branch.
_mirrord/cli/src/internal\proxy · high confidence
Background mirrord UI daemon with context-aware API v2 and chaos management
The mirrord UI now runs as a persistent background daemon process, handling local session discovery, authentication, and shared database port forwards. It exposes a new versioned API (v2) that is context and namespace-aware, allowing the browser interface to query multiple clusters simultaneously without shared server state. The UI also introduces endpoints for managing ChaosRules (CRUD operations for latency and other traffic effects) and integrates with the operator to display preview environment phases, failure reasons, and pod output.
mirrord/cli/src/ui · high confidence
Chaos latency delays outgoing connection traffic
The outgoing interceptor now supports chaos latency simulation by introducing a \DelayQueue\ that holds read and write messages until a configured deadline. When a chaos rule matches an outgoing connection, the interceptor routes traffic through background tasks (\InterceptorReadQueue\ and \AgentWriteQueue\) that enforce this delay, ensuring messages are released in insertion order to preserve byte stream integrity. This change also integrates backpressure handling for client-to-agent writes, releasing write-budget permits only when messages are actually sent to the agent.
mirrord/intproxy/src/proxies/outgoing/interceptor · high confidence
Embeds documentation and skills corpus into the binary
The mirrord MCP client now bundles its documentation and skills data directly into the executable. A new build script compresses the contents of the \corpus/\ directory (including both \docs\ and \skills\ folders) into a gzipped tar archive, which is then embedded at compile time. This ensures the necessary reference materials are available locally without requiring external file access.
mirrord/mcp · high confidence
Expanded Kubernetes target support for CronJob, Job, ReplicaSet, StatefulSet, Service, and Rollout
The mirrord runtime API now supports targeting additional Kubernetes resource types beyond Deployments and Pods. New implementation files in \mirrord/kube/src/api/runtime\ add support for CronJob, Job, ReplicaSet, StatefulSet, Service, and ArgoCD Rollout targets. This allows users to mirror traffic to workloads managed by these controllers, with specific handling for label-based selection (e.g., Service, LabelTarget) and selector extraction (e.g., CronJob, StatefulSet, Rollout).
mirrord/kube/src/api/runtime · high confidence
Expanded queue splitting and database branching support in operator client
The operator client now supports a significantly broader range of queue splitting targets, including Kafka, RabbitMQ, Google Pub/Sub, Azure Service Bus, Redis Pub/Sub, Temporal, BullMQ, and NATS, with configurable jq filters and protobuf payload decoding for Kafka. Additionally, database branching capabilities have been extended to include MySQL, PostgreSQL, MongoDB, ClickHouse, CockroachDB, MariaDB, DynamoDB, Google Spanner, S3, and Turbopuffer, with specific client logic for creating, monitoring, and reusing branch databases for each supported type. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Refactor operator client to use namespaced API routes and add serverless sessions-manager support.
mirrord/operator/src/client · medium confidence · unverified
Initial Go runtime syscall interception layer for Linux
Added a new \mirrord/layer-go\ crate that enables mirroring for Go applications on Linux (x86\_64 and aarch64). This component hooks into the Go runtime's internal syscall entry points (such as \runtime.asmcgocall\ and \Syscall6\) using assembly trampolines, allowing the tool to intercept and manage syscalls that bypass standard libc interposition. It includes architecture-specific hooking logic for different Go versions (1.19+) and a handler for \vfork\/\clone\ syscalls to ensure safe process isolation during mirroring.
mirrord/layer-go · high confidence
Initial Vale configuration and CI integration
Added the initial Vale configuration for the project, including a custom MetalBear vocabulary to recognize domain-specific terms (e.g., mirrord, Kubernetes, Rust ecosystem terms), a Tree-sitter view to correctly lint Rust doc comments as Markdown, and a custom HTML report template for CI output.
.vale/styles/config · high confidence
Initial Windows layer support with memory validation utilities
This change introduces the initial alpha version of the Mirrord layer for Windows. It adds a macro to simplify the definition of the DLL entry point (\DllMain\) and provides a utility function to validate if a memory pointer is valid within the process address space by checking its allocation state.
mirrord/layer-win/src/macros, mirrord/layer-win/src/process/memory · high confidence
Introduce Chaos API for managing latency rules
The mirrord UI now exposes an internal API to manage chaos (latency) rules for active sessions. This change adds handlers for creating, listing, updating, and deleting chaos rules, as well as clearing all rules for a session, by forwarding requests to the intproxy session monitor. It also introduces error handling for cases where a session is not found or upstream communication fails.
mirrord/cli/src/ui/chaos · high confidence
Introduce Chaos Testing via Fault Injection Rules
The intproxy session monitor now supports a Chaos feature that allows users to define rules for injecting faults into network traffic during a mirrord session. This location implements the core rule management logic, including the \ChaosRule\ data structure and the API handlers for creating, reading, updating, and deleting these rules. Users can configure selectors (currently TCP) and effects (such as latency) to simulate network conditions, with the system tracking rule usage and lifetime for analytics reporting.
_mirrord/intproxy/src/session\monitor/chaos · high confidence
Introduce Chaos testing feature and Unix socket support for outgoing connections
The outgoing proxy now supports the new Chaos testing feature, allowing users to inject connection errors, latency, resets, and stalls into intercepted traffic via configurable rules. Additionally, Unix socket support has been added for outgoing connections in container mode, ensuring proper permissions for cross-UID access, and the proxy now handles SOCK\_SEQPACKET protocol types.
mirrord/intproxy/src/proxies/outgoing · high confidence
Introduce VPN mode for mirrord
Added a new VPN feature that allows mirrord to intercept traffic by creating a virtual network interface (TUN device) and routing it through the mirrord agent. This includes platform-specific logic for Linux (mounting routes and overriding /etc/resolv.conf) and macOS (using /etc/resolver and route commands), along with the necessary agent communication protocol to handle network configuration, packet forwarding, and checksum patching.
mirrord/vpn · high confidence
Introduce \`mirrord operator install\` and \`uninstall\` commands
Users can now install and uninstall the Mirrord operator directly from the CLI. The install command fetches the latest operator manifest, validates the cluster state, and starts a trial license if needed, while the uninstall command safely removes the operator and its resources. Both commands include pre-flight checks to prevent conflicts with existing installations and provide clear error messages and usage reporting.
mirrord/cli/src/operator/install · high confidence
Introduce \`mirrord up\` for multi-service local development
This release adds the \mirrord up\ command, allowing you to run multiple mirrord sessions from a single \mirrord-up.yaml\ configuration file. You can define multiple services with distinct traffic modes (Split, Replace, or Mirror), run pre-commands before sessions start, and override working directories. An interactive \mirrord up init\ wizard helps generate the initial configuration by picking targets from your current Kubernetes context. The command also supports per-service configuration patches, database branching, and queue splitting, with robust process supervision and graceful shutdown handling across Unix and Windows platforms.
mirrord/up · high confidence
Introduce database-specific Custom Resource Definitions for branching
The operator now defines dedicated Kubernetes Custom Resource Definitions (CRDs) for each supported database engine—PostgreSQL, MySQL, MongoDB, and others—under the group \dbs.mirrord.metalbear.co\ (version \v1alpha1\). These resources (e.g., \PgBranchDatabase\, \MysqlBranchDatabase\, \MongodbBranchDatabase\) allow users to configure database-specific branching options, including connection sources, data copy modes (empty, schema, or all with filters), and engine-specific settings like IAM authentication for PostgreSQL. This replaces the previous generic \BranchDatabase\ CRD with specialized types that expose engine-specific capabilities directly in the Kubernetes API.
_mirrord/operator/src/crd/db\branching · high confidence
Introduce medschool CLI tool for extracting Rust documentation
A new \medschool\ command-line tool is added to extract documentation from Rust source code into a Markdown file. The tool parses Rust structs, enums, and modules using \syn\, resolves references to a specified root type, and outputs a structured \configuration.md\ file. It supports command-line arguments to define the root type, specify input/output paths, and prepend custom headers. Logging is controlled via the \MIRRORD\_LOG\ environment variable.
medschool/src · high confidence
Introduce mirrord configuration wizard
The mirrord configuration wizard is now available as a React application in \packages/wizard\. It provides a guided interface for creating \mirrord.json\ files, allowing users to select between Filtering, Mirror, and Replace modes, configure target namespaces and ports, and manage HTTP filters. The wizard connects to a backend API to fetch Kubernetes cluster details and includes a mock server for local development. Also in this area: 1 commit (0 fixes) modifying packages/wizard.
packages/wizard/src/components, packages/wizard/src/lib, packages/wizard/src/test · medium confidence · unverified
Introduce mirrord-jaq for SQS configuration and a new test macro
The mirrord/jaq crate now provides a dedicated library for evaluating jq filters, featuring compile-time validation via VerifiedJqString, asynchronous evaluation with configurable timeouts, and structured error reporting for load, compile, and evaluation failures. This library is utilized for SQS configuration, replacing the previous jaq-all dependency. Additionally, a new test macro in mirrord/test-macros allows async tests to run with optional timeouts and background runtime shutdown, preventing hangs from spawned blocking tasks.
mirrord/jaq · high confidence
Introduce mirrord/tls-util crate for TLS certificate and channel management
The new \mirrord/tls-util\ crate provides shared utilities for handling TLS operations, including parsing PEM certificate chains and private keys, generating temporary certificates, and establishing secure TLS channels. It introduces \SecureChannelSetup\ to create temporary, mutually-authenticated TLS connections using certificates stored in \\~/.mirrord/temp\, which ensures compatibility with container runtimes like Colima that cannot access the system temp directory. The crate also exposes helpers for building root certificate stores from files and directories, extracting Subject Alternate Names (SANs) from certificates, and a \MaybeTls\ wrapper to abstract over plain TCP and TLS connections.
mirrord/tls-util · high confidence
Introduce operator client library and CRD definitions
This change introduces the core Rust client library (\mirrord/operator/src/client.rs\) and Custom Resource Definition (CRD) schemas (\mirrord/operator/src/crd.rs\) for the mirrord operator. For users, this establishes the foundational API for managing operator sessions, including support for isolated operators, unified database branching, and queue splitting. The client now handles operator discovery, certificate preparation, and connection parameters (including sending connect params in headers to bypass ingress proxy limitations). The CRDs define the structure for Targets, Copy Targets, Database Branches, and Preview Sessions, enabling the CLI to interact with the operator for features like target resolution, session management, and license tracking.
mirrord/operator/src · high confidence
Introduce sessions-manager client for agent and intproxy connections
Added a new sessions-manager client library that enables agents and intproxies to connect to the sessions-manager service. The client handles control-plane subscriptions via Server-Sent Events (SSE), including automatic reconnection, deduplication of assignment replays, and liveness monitoring. It supports two authentication mechanisms: agents authenticate using a MetalBear API key exchanged for a short-lived cloud token, while intproxies authenticate using the developer's mirrord login token. The client also validates service scopes, manages data-plane connection upgrades, and ensures secure transmission of credentials.
mirrord/sessions-manager/client · high confidence
Introduce the Session Monitor UI for local and operator sessions
The \packages/monitor\ package now provides a dedicated React-based UI for monitoring Mirrord sessions. It supports both local and operator sessions, allowing users to select Kubernetes contexts and namespaces, view live traffic events with filtering and search, and manage chaos rules. The interface integrates with the \mirrord-ui\ shell via a top-bar slot, includes an operator installation wizard, and captures telemetry (with session recording and user-facing error reporting) via PostHog.
packages/monitor · high confidence
Introduce the \`mirrord mcp\` server for AI agent integration
A new \mirrord mcp\ binary is available, implementing the Model Context Protocol (MCP) over stdio to allow AI coding agents to interact with mirrord. The server exposes several tools: \validate\_config\ to check \mirrord.json\ or \mirrord-up.yaml\ against the installed version's schema, \explain\_config\_option\ to describe configuration options, \get\_skill\ to retrieve step-by-step guides for mirrord tasks, and \search\_docs\/\read\_doc\ to query vendored documentation. It also serves resources like \mirrord://info\ for installation details and \mirrord://skills/\<name\>\ for skill content. Usage is reported via the existing analytics system.
mirrord/mcp/src · high confidence
Introduce the mirrord Terminal UI (TUI)
Adds a new terminal-based interface for mirrord, providing a full-screen application with multiple screens for managing Kubernetes contexts, namespaces, targets, sessions, databases, queues, and preview environments. The UI features a status bar that displays connection state and scopes, and includes a dedicated error dialog for connection failures that captures and displays stderr output from authentication plugins (like gke-gcloud-auth-plugin) to help users resolve credential issues. It also implements anonymous usage telemetry reporting for actions such as session starts and tab visits, and ensures safe integration with long-lived processes by properly managing terminal state, panic hooks, and stderr redirection.
mirrord/tui/src · high confidence
Introduces \`cargo xtask\` build automation tool
Developers can now use the new \cargo xtask\ CLI to build, test, and run mirrord locally, replacing previous shell scripts. The tool provides commands like \build-cli\ to compile the full CLI (including the merged UI frontend and layer) for specific platforms (macOS universal, Linux, Windows) and \build-ui\ to compile the frontend assets. It also includes \test-e2e\, \test-integration\, and \test-ut\ for running test suites, and \run-cli\ for quick local development. The build process handles cross-compilation, macOS universal binary creation via \lipo\, and code signing (using \gon\ in CI or ad-hoc \codesign\ locally). Also in this area: Improved corpus config check reliability and error messaging; Updated corpus indexing exclusions in xtask.
xtask · high confidence
Introduces the mirrord-protocol client library with retry and connection management
The \mirrord/protocol-api/src/client\ module now provides the core client library for the mirrord protocol. This includes a \MirrordClient\ backed by a background \ClientTask\ that manages the connection lifecycle, including automatic reconnection on loss and ping-pong keep-alive. The library introduces a \MirrordClientRetry\ extension trait that adds automatic retry logic for operations like DNS lookups, file access, and port subscriptions, handling transient connection errors and agent restarts transparently. Configuration for timeouts and buffer capacities is centralized in \ClientConfig\, and the client supports both V1 and V2 protocol versions for outgoing connections and DNS lookups.
mirrord/protocol-api/src/client · high confidence
Introduction of \`hook\_fn\` and \`hook\_guard\_fn\` procedural macros for C FFI hooks
The \mirrord/layer/macro\ crate now provides two new procedural macros, \hook\_fn\ and \hook\_guard\_fn\, to simplify the creation of C FFI hook functions. \hook\_fn\ automatically generates the necessary type aliases and static variables for storing original function pointers, while \hook\_guard\_fn\ extends this by wrapping the function body with a guard check that bypasses the hook when necessary. This reduces boilerplate for defining detours in the mirrord layer.
mirrord/layer/macro · high confidence
Introduction of container-based internal proxy sidecar
The CLI now supports running the internal proxy inside a dedicated container sidecar. This change introduces a builder for constructing container runtime commands (supporting Docker, Podman, and Nerdctl) and logic to manage a sidecar container that exposes the proxy to the user's application container via shared volumes and network configuration. It also includes utilities for displaying commands and handling errors specific to container execution, such as TLS PEM access and host proxy connection failures.
mirrord/cli/src/container · high confidence
Introduction of the \`mirrord-protocol\` crate with versioned wire format and new capabilities
The \mirrord-protocol\ crate has been introduced to centralize the definition of the wire format used for communication between mirrord components (CLI, agent, operator). The protocol is versioned independently and uses \bincode\ for serialization, ensuring backwards compatibility through strict rules on type changes and version negotiation. This release adds support for several new capabilities, including HTTP/2 framing for stealer traffic, advanced HTTP filtering with JSON path and jaq support, reverse DNS lookups for outgoing network policies, and V2 statfs requests with additional filesystem metadata. It also introduces support for SOCK\_SEQPACKET sockets, share links for session joining, and operator latency ping-pong metrics. The pause feature has been removed from the protocol.
mirrord/protocol · high confidence
Major restructuring of the configuration system with new modules and features
The configuration module has been significantly reorganized into dedicated files for agent, CI, container, external proxy, internal proxy, and feature-specific settings. This change introduces new configuration capabilities including a session key system for traffic filtering, environment variable remapping via regex patterns, and enhanced logging controls for proxies. The refactoring also adds support for container runtime detection, host gateway mechanisms, and improved error handling for config parsing and template rendering.
mirrord/config/src · high confidence
New \#\[boxed\_future\] macro to reduce stack usage for async functions
The mirrord-macros crate now provides the \#\[boxed\_future\] attribute, which allows async functions to build their futures on the heap rather than the stack. This prevents large stack frames in callers, which is particularly useful for functions that await different large futures in different branches. The macro ensures that return types are correctly coerced to declared types (including unsizing) and that all argument patterns remain valid within the future's scope until completion.
mirrord/macros · high confidence
New CLI commands for operator installation, session management, and status reporting
Users can now install the mirrord operator into a Kubernetes cluster via \mirrord operator install\, which handles license acquisition (including trial starts), manifest fetching, permission checks, and deployment with progress tracking. Session management is exposed through \mirrord operator session\, allowing users to stop, kill all, or retain active sessions via the operator's session CRD. Additionally, \mirrord operator status\ provides a detailed view of current operator activity, displaying Kafka topic filtering and SQS queue splitting information in a tabular format.
mirrord/cli/src/operator · high confidence
New CLI subcommands for CI, browser extension, and process attachment
The CLI now includes three new capabilities: a \mirrord ci\ subcommand with \start\, \stop\, and \container\ actions for CI environments (requiring the \MIRRORD\_CI\_API\_KEY\ environment variable); a browser extension integration that automatically opens Chrome on macOS/Linux to configure header filters for the extension; and a \mirrord attach\ command that injects the mirrord layer DLL into an already-running process by PID, relying on the IDE extension to have pre-configured the necessary environment variables.
mirrord/cli/src · high confidence
New CRD types for preview environments, copy targets, and queue splitting
The operator now defines Kubernetes Custom Resource Definitions for managing preview environments (\PreviewSession\), copy targets (\CopyTarget\), and queue splitting sessions (\MirrordKafkaEphemeralTopic\, \MirrordRMQSession\). These resources allow the operator to track the lifecycle of preview pods, manage ephemeral queue topics, and expose queue-splitting status, enabling users to create isolated preview environments with specific configurations for traffic, environment variables, and queue filtering.
mirrord/operator/src/crd · high confidence
New HTTP filtering and TLS delivery configuration options
The incoming network configuration now supports granular HTTP traffic filtering via \header\_filter\, \path\_filter\, \method\_filter\, \body\_filter\, and \header\_filter\_jq\, including composite \all\_of\ and \any\_of\ logic for complex matching rules. Additionally, the \tls\_delivery\ section allows users to control how stolen TLS traffic is delivered locally, supporting both plain TCP and TLS protocols with options for custom trust roots, server names, and mutual TLS client certificates.
mirrord/config/src/feature/network/incoming · high confidence
New MCP tools for config validation, explanation, and documentation search
The mirrord MCP server now includes four new tools to help agents interact with configuration and documentation without network access. The \validate\_config\ tool checks \mirrord.json\ or \mirrord-up.yaml\ content against the compiled schema, reporting specific issues like duplicate keys or invalid values. The \explain\_config\_option\ tool describes individual configuration options, including their types, allowed values, defaults, and required mirrord plans, and suggests corrections for typos. The \search\_docs\ tool performs keyword search over vendored documentation and skills using BM25 ranking, while \read\_doc\ serves the full text of specific documentation pages or config option descriptions.
mirrord/mcp/src/tools · high confidence
New Preview Environments screen in the TUI
The TUI now includes a dedicated screen for managing preview environments, featuring a hierarchical tree view of sessions grouped by namespace and target. This screen provides live background updates via Kubernetes watch streams, supports filtering and search, and allows users to stop single environments or entire targets/namespaces with confirmation dialogs. It also implements brand-specific color coding for session phases (Ready, Idle, Paused, etc.) with fallbacks for terminals that do not support truecolor.
_mirrord/tui/src/screens/preview\envs · high confidence
New Windows file I/O hook infrastructure
The Windows layer now includes a dedicated file-system hooking module (\mirrord/layer-win/src/hooks/files\) that intercepts NT-level file operations such as create, read, write, and set information. This change introduces a managed handle registry to track file handles, utilities for validating IO pointers and writing status blocks, and helper functions for remote file metadata and seeking, enabling the layer to redirect and manage file I/O for Node.js and other Windows applications.
mirrord/layer-win/src/hooks/files · high confidence
New Windows utility crate for crash diagnostics, security, and internal thread handling
A new \mirrord/utils-win\ crate has been introduced to centralize Windows-specific utilities shared across the injected layer, CLI, and intproxy. This includes a comprehensive crash diagnostics system that captures exceptions and cumulative crash archives, with support for disabling reporting in IDE extension sessions via environment variables. The crate also introduces \CurrentUserSecurityAttributes\ to restrict file and named pipe access to the current user only, replacing default permissive ACLs. Additionally, it provides an \InternalGuard\ mechanism to mark mirrord's own threads, preventing internal proxy and crash handler traffic from being intercepted by hooked APIs, along with helpers for safe clipboard text copying, allocation-free formatting in crash contexts, and secure system DLL loading.
mirrord/utils-win/src · high confidence
New \`mirrord ci\` commands and global config management
Users can now manage CI sessions directly via \mirrord ci start\, \mirrord ci stop\, and \mirrord ci container\ commands, which support keyless authentication for Free and Teams operators while retaining API key support for Enterprise setups. Additionally, a new \mirrord config\ interface allows users to set or unset global configuration values using dotted field paths (e.g., \mirrord config set agent.image 'custom.image/latest'\), replacing previous JSON pointer syntax for global mutations.
mirrord/cli/src/config · high confidence
New \`mirrord ci\` subcommands for containerized and background execution
This change introduces the \mirrord ci container\, \mirrord ci start\, and \mirrord ci stop\ commands, enabling mirrord to be used in CI environments. The \mirrord ci container\ command spawns the user's binary within a container, allowing it to persist after the CLI exits. The \mirrord ci start\ command launches mirrord in the background (similar to \mirrord exec\ but detached), while \mirrord ci stop\ handles cleanup by terminating associated processes and containers. These commands rely on a new \CiStore\ for state management and specific error handling for CI-specific requirements like API keys and environment variables.
mirrord/cli/src/ci · high confidence
New authentication module for CLI operator credentials
The \mirrord/auth\ crate introduces a dedicated authentication layer for the CLI, handling the storage and lifecycle of X.509 certificates and private keys used to communicate with the mirrord operator. It provides a \CredentialStore\ that persists credentials to \\~/.mirrord/credentials\, manages key pair generation and rotation, and supports license renewal by mapping signing keys to operator subscription IDs. The module also includes a \CiApiKey\ container for CI integration and ensures compatibility with legacy key formats via DER patching.
mirrord/auth · high confidence
New background IO buffering, throttling, and timeout utilities for the agent
The agent now includes new utility modules in \mirrord/agent/src/util/io\ to improve outgoing traffic handling. \buffered.rs\ adds \UnboundedBufferedStream\ and \UnboundedBufferedSink\ wrappers that offload IO operations to background Tokio tasks, allowing connections to be progressed concurrently. \throttle.rs\ introduces \Throttle\, \ThrottledStream\, and \ThrottledSink\ to rate-limit client data flow using semaphore-based permits. \timeout.rs\ provides a \TimeoutSink\ that applies configurable timeouts to sink operations, addressing the lack of flow control in mirrord-protocol. These components collectively enhance stability and performance for outgoing connections.
mirrord/agent/src/util/io · high confidence
New build, installation, and release automation scripts
The repository now includes a suite of new shell and PowerShell scripts to streamline development and distribution. The \install.sh\ script provides a POSIX-compliant installer that automatically detects the platform (Linux x86\_64/aarch64 or macOS universal) and installs the latest or a specified version of mirrord. Build automation is improved with \build\_fat\_mac.sh\ and \build\_layer\_mac.sh\ for creating signed universal binaries on macOS, and \build\_c\_apps.sh\/\build\_go\_apps.sh\ for compiling test applications. A new \release.sh\ script automates version bumping and changelog generation using \towncrier\. Additionally, \prepare\_e2e.sh\ and Windows-specific scripts (\win\_build\_test\_apps.ps1\, \setup\_ci\_env\_wsl.sh\) standardize the setup of test environments across CI and local WSL setups.
scripts · high confidence
New cluster-auth crate for remote Kubernetes connections
The new \mirrord/cluster-auth\ crate provides the core logic for connecting to remote Kubernetes clusters, supporting Bearer token, mTLS, AWS IAM (EKS), and Azure Workload Identity authentication methods. It introduces a \ClusterClientFactory\ that builds HTTP/1.1 \kube::Client\ instances using temporary, securely-permissioned token files to allow the Kubernetes client to reload credentials without rebuilding the connection. For EKS clusters, it implements local token generation using presigned STS URLs and includes a background token refresh mechanism to keep connections alive. The module also handles custom TLS configuration, specifically resolving handshake issues with clusters that request client certificates during bearer token authentication by sending an empty certificate chain.
mirrord/cluster-auth · high confidence
New configuration schema for copy target, database branching, environment, file system, magic, network, preview, and queue splitting features
The configuration system in \mirrord/config/src/feature\ has been restructured into distinct modules for each feature area. This introduces a new \copy\_target\ configuration allowing users to create dynamic pods with options to scale down the original deployment and exclude specific containers. Database branching support is now centralized in \database\_branches.rs\, providing unified configuration for various engines (PostgreSQL, MySQL, CockroachDB, etc.) including copy modes, migrations, and IAM authentication. Environment variable handling (\env.rs\) now supports explicit unsetting, file-based loading, and value mapping. File system operations (\fs.rs\) are configured with modes and filters. The \magic\ module adds sensible defaults for AWS credentials, Kubernetes volume mounting, and Next.js/Turbopack compatibility. Network configuration (\network.rs\) now defaults IPv6 support to enabled. Preview environments (\preview.rs\) offer granular control over TTL, replicas, labels, idle mode, and config/secret mounts. Finally, queue splitting (\split\_queues.rs\) is configured with composable message filters and support for multiple queue types (SQS, Kafka, RabbitMQ, etc.).
mirrord/config/src/feature · high confidence
New crash diagnostics dialog on Windows
A new native Windows dialog has been added to the diagnostics utility to display crash reports. The dialog features a branded header with the Metalbear logo, a scrollable rich-text report box that renders markdown links as clickable blue text, and footer buttons to copy the report, open the relevant folder, or close the window. The UI adapts to the user's system accent color and supports dark mode on Windows 10/11.
mirrord/utils-win/src/diagnostics/dialog · high confidence
New interactive targets wizard for configuring mirrord sessions
The terminal interface now includes a new targets wizard that lets you browse cluster resources, configure service plans, and launch mirrord sessions without writing YAML manually. The wizard provides a target browser with per-kind badges, a session plan pane for ordering and editing services, and a generic settings form with tab-completion for commands and paths. It automatically detects common run commands based on project markers (e.g., package.json, Cargo.toml, go.mod) and remembers your last launch settings per target in XDG state history. You can now export your configuration to a mirrord-up.yaml file, handle lingering session conflicts with a kill-and-relaunch prompt, and navigate using standard keys plus vim-style alternatives.
mirrord/tui/src/screens/targets · high confidence
New mirrord CLI container image with cross-platform support and CA certificates
The mirrord CLI is now distributed via a dedicated Dockerfile that builds the binary and layer libraries using cargo-zigbuild for cross-compilation. The runtime image is based on Debian and includes ca-certificates to ensure HTTP clients (local daemon, analytics) can verify TLS connections. The build process supports both x86\_64 and ARM64 architectures, with ARM64 builds additionally including an x86\_64 version of the layer library to support cross-platform container scenarios. A build.rs script ensures the UI frontend placeholder exists and handles macOS-specific SIP binary packaging.
mirrord/cli · high confidence
New protocol client library with connection resilience and traffic tunneling
The \mirrord/protocol-api/src\ module introduces a new \MirrordClient\ that manages the connection to the mirrord server, featuring automatic reconnection and retry capabilities to maintain stability during network interruptions. It includes a robust traffic tunneling system for mirroring incoming connections and handling outgoing sockets, along with an \IdTracker\ to ensure consistent file descriptor IDs across reconnects. The client also implements a size-aware FIFO queue with backpressure support to manage memory usage for protocol messages and traffic data.
mirrord/protocol-api/src · high confidence
New protocol-IO module with WebSocket support
The \mirrord/protocol-io\ crate has been introduced to handle wire-level IO for the mirrord protocol. This new module provides the \Connection\ abstraction for managing message queues and scheduling, and includes a dedicated WebSocket adapter (\websocket.rs\) that integrates with \tokio\_tungstenite\ to support connections to the operator. This change establishes the foundational IO layer for protocol communication.
mirrord/protocol-io · high confidence
New session-monitor protocol defines session and port subscription data structures
The session-monitor protocol now exposes structured data for session management, including \SessionInfo\ which carries target, namespace, and Kubernetes context details for UI display, as well as \PortSubscription\ objects that now include an optional \hit\_count\ field to track connection activity. This change establishes the data contract between the session monitor and its clients, enabling features like Windows named pipe support and enhanced session visibility in the UI.
mirrord/session-monitor-protocol · high confidence
New session-monitor-client library for cross-platform session management
Added a new \mirrord/session-monitor-client\ library that provides a cross-platform HTTP client for interacting with the per-session API exposed by mirrord-intproxy's session monitor. On Unix, it communicates via Unix domain sockets, while on Windows, it uses named pipes with a sentinel file for discovery. The client handles session endpoint resolution, request building, and response parsing, including support for Server-Sent Events (SSE) for streaming data. It also includes error handling for upstream session monitor errors and implements retry logic for Windows named pipe connectivity issues.
mirrord/session-monitor-client · high confidence
New shared WebSocket transport crate for operator connections
A new \mirrord-operator-websocket\ crate has been introduced to centralize the WebSocket transport layer used by operator API consumers. This crate provides \connection.rs\ to adapt upgraded WebSocket streams into \mirrord-protocol\ streams and sinks, and \upgrade.rs\ to handle the WebSocket handshake via the Kubernetes API server or direct HTTPS endpoints. This change decouples the transport logic from higher-level operator concerns like CRDs and credentials, allowing the agent to establish protocol connections without depending on the full operator client stack.
mirrord/operator-websocket · high confidence
New terminal interface screens for managing sessions, targets, and databases
The terminal UI now includes dedicated screens for browsing and managing branch databases, queue-splitting sessions, preview environments, and mirrord sessions, alongside a targets wizard for configuring and launching services and an interactive shell pane with session tracking. This adds the first concrete user-facing screens for these capabilities, replacing the previous placeholder or non-existent state with functional, navigable interfaces.
mirrord/tui/src/screens · high confidence
New terminal pane for interactive mirrord sessions
A new terminal pane has been added to the TUI, allowing users to spawn a shell and view active mirrord sessions in a side panel. The pane manages a pseudo-terminal (PTY) to run the child shell, correctly handling terminal resizing and encoding keystrokes (including cursor keys and modifiers) to ensure compatibility with full-screen applications like vim or less. The side panel automatically detects sessions running under the pane's shell by walking the process tree, displaying session targets, port subscription modes (steal/copy), and uptime, while polling the local session registry for real-time updates.
mirrord/tui/src/screens/terminal · high confidence
Preview now supports applying specific Kubernetes resources via --resource
The \mirrord preview\ command now accepts a \--resource\ flag to apply specific Kubernetes manifests (Deployments, ConfigMaps, Secrets) to the preview environment. This feature introduces a new pipeline that loads and parses YAML files, scopes them to only the resources the target pod uses, and compares them against the live cluster state. Users can now use \preview start --resource\ to update specific resources or \preview diff\ to inspect changes before applying them. The implementation also adds support for rendering Helm charts via \--chart\ and \--values\, allowing users to apply templated resources directly.
mirrord/cli/src/preview/resources · high confidence
Repository structure and developer tooling overhaul
The repository has been reorganized to improve developer experience and security posture. A new monolithic CLAUDE.md file now serves as the primary instruction set for AI coding agents, replacing previous per-crate instructions. A comprehensive STYLE.md guide has been added to standardize Rust code conventions, and a new SECURITY.md file establishes a formal vulnerability reporting process. Developer tooling is enhanced with new configuration files for markdown linting (.markdownlint.json), code formatting (.prettierrc.json), and prose validation (.vale.ini). Additionally, the project now includes a Cross.toml for cross-compilation support, a deny.toml for dependency auditing, and a flake.nix/flake.lock for Nix-based development environments.
(repo-wide) · high confidence
Secure per-session HTTP API for session monitoring and chaos testing
The session monitor now exposes a local HTTP API to inspect session state and manage chaos testing rules. On Unix, this is served over a Unix socket with \0o600\ permissions; on Windows, it uses a named pipe with a restrictive DACL allowing access only to the current user, ensuring confidentiality of sensitive session data like process names and file paths. The API provides endpoints for health checks, session information, and server-sent events for real-time monitoring, as well as a dedicated router for creating, updating, and deleting chaos rules to simulate network conditions.
_mirrord/intproxy/src/session\monitor · high confidence
Support for Argo Rollout targets and improved port-forward reliability
Mirrord now supports targeting Argo Rollout resources, allowing users to mirror traffic from applications managed by Argo Rollouts. This includes handling both inline pod templates and those referenced via \workloadRef\, with support for underlying workloads like Deployments, ReplicaSets, StatefulSets, and PodTemplates. Additionally, a new port-forwarding implementation with automatic retry logic has been introduced to improve connection stability when communicating with the mirrord agent.
mirrord/kube/src/api/kubernetes · high confidence
Unified layer library with cross-platform debugger detection and logging
The \mirrord/layer-lib\ crate now provides a shared codebase for both Unix and Windows layers, introducing a new \debugger\_ports\ module that automatically detects and ignores ports used by debuggers (DebugPy, PyDevD, ReSharper, JavaAgent, and NodeInspector) to prevent them from being intercepted. Logging is unified via the \MIRRORD\_LAYER\_LOG\_PATH\ environment variable, and the layer now respects the \JB\_IDE\_PORT\ environment variable for JetBrains IDEs. The library also includes a new \detour\ module for managing hook bypasses, a \Mutex\ wrapper with a \MIRRORD\_NODEADLOCK\ mode to prevent deadlocks, and support for \SOCK\_SEQPACKET\ sockets.
mirrord/layer-lib/src · high confidence
Unified mirrord UI with Session Monitor, Events, and Config Wizard
The \packages/ui\ location now serves as the single entry point for the mirrord interface, merging the previously separate Session Monitor and Config Wizard into one application with a shared top navigation bar. Users can now switch between the Session Monitor, a new Events tab, and the Config Wizard without losing state, as features are lazy-loaded and kept mounted. The UI also introduces a neutral dark gray palette for dark mode to improve readability, a global light/dark theme toggle in the header, and a shared error boundary to catch crashes across all features.
packages/ui · high confidence
Windows crash and exception diagnostics with preview tools
The Windows layer now captures crash and exception diagnostics, presenting a dedicated dialog to the user when a process under mirrord crashes, is terminated, or fails to initialize. This includes reporting the crash details, process tree, and mirrord version, along with links for support. To help developers verify these scenarios, new preview examples (preview\_dialog, preview\_scenarios) allow simulating crash, kill, fastfail, and initfail events locally without triggering a real crash.
mirrord/utils-win · high confidence
Windows crash diagnostics and native error dialog
Added a comprehensive crash-diagnostics subsystem for the Windows layer, including an in-process exception handler that writes text records and minidumps, an out-of-process monitor that safely captures dumps via named events and shared memory, and a native Win32 crash dialog featuring the metalbear logo, a markdown-rendered report with clickable links, and buttons to copy, open the folder, or report the issue.
mirrord/utils-win/src/diagnostics · high confidence
Windows installer package definition added
The project now includes the necessary WiX source files (main.wxs and License.rtf) to build a Windows MSI installer. This package installs the mirrord executable and its Windows-specific layer DLL into the Program Files directory and automatically adds the installation bin folder to the system PATH, enabling users to run mirrord commands from any location on Windows.
mirrord/cli/wix · high confidence
Windows layer crash diagnostics and stable startup initialization
The Windows layer now includes comprehensive crash diagnostics and a more robust initialization sequence. A new diagnostics module captures early startup snapshots (process name, session role) and full process context (module inventory, security product flags) to aid in troubleshooting failures. It registers with an out-of-process crash monitor to report initialization failures and generate memory dumps when enabled. The startup process is split into loader-lock-safe synchronous initialization (hook installation) and asynchronous background work (proxy connection, diagnostics logging) to prevent races and ensure the layer reports readiness correctly. A dedicated task pool manages background jobs for IOCP and DNS resolution, improving stability and performance.
mirrord/layer-win/src · high confidence
Windows process creation interception and injection logic
The Windows layer now intercepts the internal \CreateProcessInternalW\ API to inject the mirrord DLL into child processes. This implementation parses caller environments to determine the injection method, extracts safe program identifiers for logging (excluding arguments to protect secrets), and manages process lifecycle by handling failures via a \LayerFailurePolicy\ (either running without mirrord or terminating with \ERROR\_DLL\_INIT\_FAILED\). It also hooks \LoadLibraryW\ and \GetProcAddress\ to detect module loading during the injection phase.
mirrord/layer-win/src/hooks/process · high confidence
Windows process layer: elevation checks and environment parsing
The Windows process layer now includes utilities to detect and enforce UAC elevation requirements for mirrord operations, as well as robust parsing of child process environment blocks. The new \elevation\ module queries the Windows process token to determine if the current process has Administrator privileges, allowing the tool to gracefully exit with a clear reason if elevation is required but missing. Additionally, the \environment\ module correctly parses environment blocks passed during process creation, handling both ANSI and Unicode encodings based on creation flags, and preserving large environment blocks that exceed standard variable length limits. These changes ensure that mirrord behaves correctly on Windows regarding privilege requirements and environment variable inheritance.
mirrord/layer-win/src/process · high confidence
Windows socket hooks now support async DNS resolution and proper hostname handling
The Windows socket interception layer now hooks \GetAddrInfoExW\ to support asynchronous DNS resolution (used by .NET and other async APIs) by emulating the Windows overlapped/completion-routine contract with atomic claim-and-deliver semantics and synthetic cancel handles. It also hooks \GetComputerNameW\/\GetComputerNameExW\ and \gethostname\ to return the remote pod's hostname, with logic to truncate or fail based on the name format (e.g., NetBIOS vs. DNS) to avoid breaking callers like .NET's \Environment.MachineName\. These changes are implemented in the new \addrinfo\_ex\, \hostname\, \ops\, and \utils\ modules within \mirrord/layer-win/src/hooks/socket\.
mirrord/layer-win/src/hooks/socket · high confidence
mirrord-agent build infrastructure and documentation added
This change introduces the build and documentation assets for the mirrord-agent component. It adds a Dockerfile that compiles the agent using a specific nightly Rust toolchain (2026-08-13) and the mold linker for performance, utilizing a shared CI build image. It also includes a platform detection script (platform.sh) to handle cross-compilation for amd64 and arm64 architectures. Additionally, a CONTRIBUTING.md guide is added to establish logging standards and warn against blocking the single-threaded Tokio runtime, while a README.md documents the agent's purpose and provides configuration examples for enabling Prometheus metrics. Finally, a nightly-polyfill library is added to provide stable Rust stand-ins for unstable nightly features like std::error::Report.
mirrord/agent · high confidence
Architecture
Agent refactored into modular source files with new CLI and TLS support
The agent source code has been reorganized from a single monolithic file into distinct modules (cli, client\_connection, container\_handle, dns, entrypoint, env, error, file, http, incoming, main). This change introduces a new command-line interface for configuring the agent, adds support for TLS-secured client connections via an \AgentTlsConnector\, and extracts environment variable filtering logic into a dedicated module. The agent now uses a modular structure for better maintainability while preserving its core functionality for traffic interception and management.
mirrord/agent/src · high confidence
Agent startup logic refactored into dedicated setup module
The agent's initialization process has been restructured by introducing a new \setup.rs\ module that explicitly manages the lifecycle of core background tasks. This change centralizes the creation and configuration of the traffic redirector (handling both steal and mirror modes), the TCP stealer, and the DNS worker, ensuring they are spawned on the designated background runtime. Users benefit from a more robust and maintainable agent startup sequence that clearly separates task configuration from execution.
mirrord/agent/src/entrypoint · high confidence
Consolidate CI image definitions using Docker Bake
The CI infrastructure has been restructured to use Docker Bake (docker-bake.hcl) for defining and building images, replacing the previous scattered approach. This change introduces dedicated builder and runtime images for the agent (including a minimal scratch-based runtime with collected dynamic dependencies) and specific cross-compilation images for the mirrord-layer targeting x86\_64 and aarch64 with older glibc versions (CentOS 7/Amazon Linux 2 support). It also establishes a base Rust build image with a pinned toolchain, streamlining how CI images are tagged and cached across the repository.
ci · high confidence
Extracted agent environment configuration into a dedicated crate
The mirrord-agent's environment variable definitions and their type-safe parsing logic have been extracted into a new, standalone \mirrord/agent/env\ crate. This change introduces a \CheckedEnv\ framework that enforces strict type checking for configuration values (such as \SocketAddr\, \bool\, and \Vec\<IpAddr\>\) and provides utilities for generating Kubernetes \EnvVar\ specs. The crate centralizes the definitions of all agent configuration variables (e.g., \MIRRORD\_AGENT\_METRICS\, \MIRRORD\_AGENT\_STEAL\_TLS\_CONFIG\, \MIRRORD\_AGENT\_CLEAN\_IPTABLES\_ON\_START\) and includes the \MeshVendor\ enum and \StealPortTlsConfig\ structures, ensuring that environment handling is consistent, backward-compatible, and isolated from the rest of the agent's implementation.
mirrord/agent/env · high confidence
Internal proxy refactored into a modular background-task architecture with robust failover and process termination
The internal proxy has been restructured to manage its components (agent connection, layer connections, ping-pong, and various proxies) as independent background tasks coordinated by a central message bus. This change introduces a dedicated failover strategy that detects unrecoverable agent connection losses and actively terminates all injected user processes to prevent them from lingering as zombies holding ports. It also adds a new \LayerInitializer\ to handle layer handshakes sequentially, ensuring clean shutdown and quiescence, while the \AgentConnection\ and \PingPong\ tasks are now restartable to handle transient network issues more resiliently.
mirrord/intproxy/src · high confidence
Refactor hooking infrastructure into mirrord-layer-core
The layer's hooking logic has been moved from \mirrord/layer/src/hooks.rs\ into a new \mirrord-layer-core\ crate. This introduces a centralized \HookManager\ for managing Frida-based detours and provides macros (\replace\, \replace\_with\_fallback\, \hook\_symbol\) to simplify installing hooks for libc functions and Go symbols. The \mirrord/layer\ crate now re-exports these core hooking utilities, unifying how system calls are intercepted across different platforms and runtimes.
mirrord/layer/src · high confidence
Refactored config derive macro internals
The internal implementation of the \\#\[config\]\ attribute macro has been restructured by introducing dedicated \ConfigField\ and \ConfigFlags\ modules. This change separates the parsing of configuration attributes (such as \env\, \default\, \nested\, \rename\, \unstable\, and \deprecated\) from the code generation logic, resulting in a more modular and maintainable derive macro implementation.
mirrord/config/derive/src/config · high confidence
Refactored internal proxy into modular file, incoming, outgoing, and simple proxies
The internal proxy logic has been reorganized into distinct, dedicated modules for handling specific traffic types: \files.rs\ manages file system operations with buffering and agent-loss handling, \incoming.rs\ handles incoming TCP and HTTP connections (including mirroring, stealing, and HTTP upgrades), \outgoing.rs\ manages outbound network connections with support for non-blocking flows and Unix sockets, and \simple.rs\ handles straightforward passthrough requests like DNS lookups and environment variable retrieval. This structural change improves code maintainability and isolates the behavior of each proxy type.
mirrord/intproxy/src/proxies · high confidence
Restructure socket hooking logic into dedicated ops and hooks modules
The socket interception logic in \mirrord/layer\ has been reorganized into \socket/hooks.rs\ and \socket/ops.rs\. This change separates the raw C-function detours (such as \socket\, \bind\, \connect\, \listen\, \accept\, \gethostbyname\, and \gethostname\) from the core business logic. The new \ops.rs\ module centralizes the handling of socket states, address binding fallbacks, and incoming port filtering, while \hooks.rs\ manages the entry points for the injected functions. This refactoring improves code maintainability and clarity for the socket layer without altering the external behavior of the tool.
mirrord/layer/src/socket · high confidence
Windows file hooks reorganized into per-operation modules
The Windows file-system hook implementation in \mirrord/layer-win/src/hooks/files/ops\ has been restructured from a monolithic file into separate modules for each operation (open, read, write, close, cancel, set\_info, query\_info, wait, and stubs). This change improves code maintainability and auditability by isolating the logic for each NT syscall hook, while preserving the existing remote file interception behavior for managed files.
mirrord/layer-win/src/hooks/files/ops · high confidence
Behavioural changes
11 commits (0 fixes) modifying mirrord/operator/src/sync
A change to existing behaviour in mirrord/operator/src/sync — 11 commits, 3 files: “operator+cli: send the ignore rules and sizes of each entry in a push”; “operator: add the manifest exchange to the code sync protocol”; “preview: reshape \sync\ into an optional \run\ and a \prepare\ (\#5201)”; and 8 more (refs \#5201).
mirrord/operator/src/sync · medium confidence · unverified
14 commits (0 fixes) modifying mirrord/cli/src/preview/sync
A change to existing behaviour in mirrord/cli/src/preview/sync — 14 commits, 1 file: “up+cli: group the settings of \preview sync\ under each service's \sync\”; “operator+cli: send the ignore rules and sizes of each entry in a push”; “cli: stop \preview sync\ when the operator refuses its connection”; and 11 more (refs \#5201).
mirrord/cli/src/preview/sync · medium confidence · unverified
3 commits (0 fixes) modifying mirrord/cli/src/up
A change to existing behaviour in mirrord/cli/src/up — 3 commits, 1 file: “up custom modes branching: look up each operator at once before launch”; “up custom modes branching: decide a request that can't be served in one place”; “up custom modes branching: rename the up pre-check module to checks”.
mirrord/cli/src/up · medium confidence · unverified
3 commits (0 fixes) modifying mirrord/mcp/src/tools/explain\_config\_option
A change to existing behaviour in mirrord/mcp/src/tools/explain\_config\_option — 3 commits, 1 file: “Baggage in mirrord up common config (\#5196)”; “mcp: move the explain\_config\_option and validate\_config tests into their own files”; “up custom modes: tests” (refs \#5196).
_mirrord/mcp/src/tools/explain\_config\option · medium confidence · unverified
4 commits (0 fixes) modifying packages/wizard/src/hooks
A change to existing behaviour in packages/wizard/src/hooks — 4 commits, 1 file: “Move wizard-frontend to packages/wizard (PRO-89) (\#4160)”; “chore(frontend): remove dead components, exports, and dependencies (\#4560)”; “Merge session monitor and config wizard into one \mirrord ui\ (\#4503)”; and 1 more (refs \#4160, \#4560, \#4503, \#4512).
packages/wizard/src/hooks · medium confidence · unverified
52 commits (2 fixes) modifying mirrord/cli/src/preview
A change to existing behaviour in mirrord/cli/src/preview — 52 commits (2 fixs), 4 files: “up+cli: group the settings of \preview sync\ under each service's \sync\”; “up, preview up: share the check for an operator that can't resolve default DB branches”; “up custom modes branching: a mode without db\_branching branches like its incoming”; and 49 more (refs \#5201).
mirrord/cli/src/preview · medium confidence · unverified
7 commits (0 fixes) modifying changelog.d
A change to existing behaviour in changelog.d — 7 commits, 5 files: “docs: name MySQL 8.4 in the database branch examples (INT-1104) (\#5225)”; “Automate release (\#4133)”; “Share release PR steps as composite actions”; and 4 more (refs \#5225, \#4133, \#5239, \#1165, \#5235, …).
changelog.d · medium confidence · unverified
8 commits (0 fixes) modifying mirrord/kube/src/resolved
A change to existing behaviour in mirrord/kube/src/resolved — 8 commits, 8 files: “Support full workload label selectors (COR-1248)”; “Support for ReplicaSet targets (\#3049)”; “Share workload selector presence checks (COR-1248)”; and 5 more (refs \#3049, \#2752, \#3065, \#3022, \#3453).
mirrord/kube/src/resolved · medium confidence · unverified
8 commits (1 fix) modifying mirrord/operator/src/crd/preview
A change to existing behaviour in mirrord/operator/src/crd/preview — 8 commits (1 fix), 3 files: “up+cli: group the settings of \preview sync\ under each service's \sync\”; “preview: reshape \sync\ into an optional \run\ and a \prepare\ (\#5201)”; “operator: move \PreviewSyncConfig\ to \crd::preview::sync\_config\”; and 5 more (refs \#5201).
mirrord/operator/src/crd/preview · medium confidence · unverified
Added home screen logo assets to the TUI
The TUI now includes dedicated resource files for the application logo, specifically 'logo-big' and 'logo-small', which are used to render the home screen visual identity.
mirrord/tui/resources · high confidence
Analytics now detects AI coding agents and reports preview environment usage
The analytics module now distinguishes usage driven by AI coding agents (Claude Code, Cursor, Codex, Gemini CLI, and Amp) by detecting specific environment variables, allowing these sessions to be identified separately from direct human usage. Additionally, the module introduces dedicated reporting for preview environment events (start, stop, status, and failure), including runtime tracking and session key identification, enabling visibility into how preview environments are utilized.
mirrord/analytics · high confidence
Default file read behavior for Windows paths changes
The Windows file layer now reads the \%TEMP%\ directory locally by default, aligning with other local-only paths like DLLs, Python folders, and Program Files. This change ensures that temporary files are not intercepted by the remote filesystem layer unless explicitly configured otherwise via \feature.fs.read\_only\ or \feature.fs.read\_write\ patterns.
mirrord/layer-lib/src/file/windows · high confidence
Fixes concurrency issues in proxy response handling
The proxy connection layer now uses a dedicated ResponseManager to safely handle incoming responses from the proxy in multi-threaded environments. This change prevents race conditions and potential hangs by coordinating access to the shared decoder using mutexes and condition variables, ensuring that responses are correctly routed to the waiting threads that requested them.
_mirrord/layer-lib/src/proxy\connection · high confidence
Improved DNS resolution reliability and memory safety
The DNS resolution layer now correctly honors the AI\_NUMERICHOST flag, preventing unnecessary remote lookups when applications are merely checking if a string is a literal IP address. Additionally, a new reverse DNS cache with a 1,000-entry limit has been introduced to map resolved IP addresses back to their hostnames, preventing potential memory exhaustion while supporting debugging and logging. Windows address info structures are now managed with explicit ownership tracking to ensure proper cleanup and prevent memory leaks.
mirrord/layer-lib/src/socket/dns · high confidence
Improved HTTP client reuse and response streaming in the incoming proxy
The incoming HTTP proxy now manages local HTTP client connections more robustly by introducing a \ClientStore\ that caches idle clients for reuse, while explicitly dropping clients that the local application has already closed to prevent hanging requests. Additionally, a new \StreamingBody\ implementation allows HTTP response bodies to be streamed efficiently via channels, and a \ResponseMode\ enum enables the proxy to select the appropriate response format (Basic, Framed, or Chunked) based on the agent's protocol version support.
mirrord/intproxy/src/proxies/incoming/http · high confidence
Improved Windows file path matching and mapping logic
The file system filtering and path remapping logic now handles Windows drive letters more robustly. Paths are matched against configuration patterns both with and without their drive letter (e.g., matching \/Repos\ against \C:/Repos\), ensuring that drive-agnostic patterns apply across all drives while drive-specific patterns target only the intended drive. Additionally, path mappings are now performed case-insensitively, and unmapped paths in \localwithoverrides\ mode are correctly kept local. These changes refine how mirrord intercepts and redirects file operations on Windows.
mirrord/layer-lib/src/file · high confidence
Improved concurrency handling for managed handles on Windows
The Windows layer now uses a sharded map to store managed handles, replacing a previous single-lock implementation that caused operations to be dropped under heavy load. This change ensures that concurrent file and DNS operations are handled reliably without loss, even when many requests occur simultaneously.
mirrord/layer-win/src/managed · high confidence
Introduce async console logging with configurable log level
The mirrord console now supports an asynchronous logging mode (enabled via the \async-logger\ feature) that sends log records to the console application over a TCP connection using an async encoder, improving reliability when the Tokio runtime is not yet initialized. The console binary itself now uses the \MIRRORD\_LOG\ environment variable to configure its own tracing log level, replacing the previous \RUST\_LOG\ setting.
mirrord/console · high confidence
New CLI data persistence layer for authentication, global config, and user data
The CLI now uses a dedicated data module to manage persistent user state. Authentication tokens and trial keys are stored in \~/.mirrord/auth.json, with tokens scoped by issuer and organization and automatically expired. Global configuration is now read from \~/.mirrord/mirrord.json (renamed from global-mirrord.json), supporting schema-validated edits and lazy loading so the UI sees context changes without restarts. User analytics data, including session counts and machine IDs, is persisted in \~/.mirrord/data.json.
mirrord/cli/src/data · high confidence
New HTTP request extraction and filtering infrastructure
The agent now uses a new internal HTTP handling layer that extracts requests into a stream, allowing for more granular control over request processing. This includes support for filtering HTTP requests by headers, paths, methods, and JSON body content using regex and JSONPath queries, as well as filtering headers using jq expressions. The system also introduces a share-link mechanism that allows users to join active mirrord sessions via a browser link, handling session key registration and cleanup. Additionally, error responses now include the agent version, and HTTP/2 requests without an authority in the URI are automatically downgraded to HTTP/1.1 to ensure compatibility.
mirrord/agent/src/http · high confidence
New SIP patching implementation with bundled utilities and Santa support
The mirrord SIP module has been rewritten to improve macOS compatibility and reliability. It now includes a pre-built bundle of system binaries (from /bin, /sbin, /usr/bin, /usr/sbin) to bypass SIP restrictions without patching protected executables, with transparent handling for aliases like sh→bash. Code signing logic has been updated to use the apple\_codesign crate for safer in-process signing, ensuring ad-hoc signatures and unique identifiers to avoid conflicts. The implementation adds support for Santa security policies via an environment variable, allowing the use of the system codesign binary to bypass Santa blocks when needed. Additionally, it introduces file-based logging for SIP operations to aid debugging, improved error handling for file descriptor limits, and version-aware extraction of the utility bundle to prevent stale patches.
mirrord/sip · high confidence
New \`not\_found\` filter and buffer size limits for file system operations
The file system configuration now supports a \not\_found\ filter, allowing users to specify path patterns that should be treated as non-existent by the application. Additionally, buffer size limits for read-only remote files have been introduced, with a warning issued for values exceeding 1 MB and a hard limit of 15 MB to prevent excessive memory usage.
mirrord/config/src/feature/fs · high confidence
New file operation hooking implementation in mirrord-layer
The file subsystem in mirrord-layer has been restructured with new modules (hooks.rs, open\_dirs.rs, ops.rs) that implement detours for standard libc file operations (open, opendir, readdir, statfs, etc.). This change introduces a new mechanism for handling file system operations by intercepting calls, applying path remapping and filtering rules, and forwarding requests to the remote agent or bypassing to local execution based on configuration. Users will experience more consistent file system mirroring behavior, particularly for directory operations and file metadata queries, as the layer now explicitly manages open directory states and applies path checks before remote operations.
mirrord/layer/src/file · high confidence
New internal proxy protocol with custom binary codec
The communication protocol between the layer and the internal proxy has been replaced with a new implementation. This new protocol defines a custom binary framing format (4-byte big-endian length prefix followed by bincode-encoded payloads) and provides both synchronous and asynchronous (feature-gated) encoders and decoders. It introduces new message types for the layer-to-proxy channel, including support for \SOCK\_SEQPACKET\ outgoing connections, and utilizes helper macros to manage request/response wrapping.
mirrord/intproxy/protocol · high confidence
New structured progress reporting system with IDE and JSON modes
The \mirrord/progress\ module has been replaced with a new implementation that supports structured progress tracking via JSON output and dedicated IDE communication channels. Users can now set the \MIRRORD\_PROGRESS\_MODE\ environment variable to \json\ for machine-readable output or rely on the new \ide()\ API for internal IDE notifications (controlled by \MIRRORD\_PROGRESS\_SUPPORT\_IDE\). The system also introduces specific warning messages for multi-pod deployments, HTTP filters, and incorrect \mirrord exec\ usage, along with a standardized \SESSION\_READY\_MESSAGE\ to signal session initialization completion.
mirrord/progress · high confidence
Optimized pre-commit hook for the wizard package
The pre-commit hook in the wizard package now skips linting when no files within the packages/wizard directory are staged. This optimization reduces startup overhead for commits that do not affect the wizard frontend, while still running lint-staged when relevant changes are present.
packages/wizard/.husky · high confidence
Refactored Kubernetes API into modular container and runtime components
The Kubernetes API logic in \mirrord-kube\ has been reorganized into distinct modules (\container\, \kubernetes\, \runtime\) to improve structure and maintainability. This change introduces a \ContainerConfig\ and \ContainerParams\ system that centralizes agent container settings, including the new \idle\_ttl\ configuration for controlling how long the agent persists after client disconnection. It also implements robust mesh vendor detection (supporting Istio Ambient, Istio CNI, Linkerd, and Kuma) and refined container selection logic that respects Kubernetes default container annotations and skips known sidecars (like Telepresence, Vault, and Cloud SQL Proxy). Additionally, the API now explicitly handles OpenShift detection more efficiently and ensures TCP\_NODELAY is set on agent connections to reduce latency.
mirrord/kube/src/api · high confidence
Refactored Kubernetes API module with new error handling and resource resolution
The \mirrord-kube\ library has been restructured to improve error reporting and target resolution. A new \KubeApiError\ enum provides specific, user-friendly error messages for issues such as missing kubeconfig fields, invalid resource states, node pod capacity limits, and agent startup failures. The module now includes a \ResolvedTarget\ system that standardizes how various Kubernetes resources (Deployments, StatefulSets, CronJobs, Services, etc.) are resolved and validated before mirroring. Additionally, a new \FromResource\ extraction trait and helper types (Name, Namespace, Uid) simplify accessing metadata from Kubernetes objects, and a \RetryPolicy\ helper integrates with the \kube\ client to automatically retry recoverable API errors during startup.
mirrord/kube/src · high confidence
Refactored MirrordConfig derive macro implementation
The internal implementation of the MirrordConfig derive macro has been restructured to improve code organization and maintainability. The macro logic is now split into dedicated modules for handling configuration fields and flags, allowing for more granular processing of struct attributes. This refactoring ensures that configuration structs are correctly generated with appropriate serialization and deserialization behaviors while maintaining backward compatibility with existing configuration definitions.
mirrord/config/derive/src · medium confidence
Refactored TCP and HTTP traffic stealing into a modular task-based architecture
The traffic stealing logic in the agent has been restructured from a monolithic implementation into distinct components: a background \TcpStealerTask\ that manages the lifecycle and distribution of stolen connections, a \PortSubscriptions\ module for handling port redirections and filtering metrics, and a \TcpStealerApi\ that serves as the communication bridge for individual client connections. This change introduces support for protocol version compatibility checks to ensure clients can handle specific traffic types (such as chunked HTTP requests or TLS upgrades), improves the handling of HTTP request body buffering, and adds comprehensive tests for scenarios including request upgrades, filtered vs. unfiltered subscriptions, and TCP passthrough.
mirrord/agent/src/steal · high confidence
Refactored agent container creation into dedicated modules with improved startup handling
The agent container creation logic in \mirrord-kube\ has been reorganized into specific modules (\ephemeral.rs\, \job.rs\, \pod.rs\, \targeted.rs\, \targetless.rs\, and \util.rs\) to separate concerns between ephemeral, job-based, and targetless agent deployments. This refactoring introduces faster failure detection for image pull errors (preventing indefinite waits in Pending state) and standardizes the use of \args\ over \command\ for agent container specifications to improve compatibility with Kubernetes restrictions like GKE Autopilot WorkloadAllowlists.
mirrord/kube/src/api/container · high confidence
Refactored configuration system with new source abstraction and context management
The configuration loading logic in \mirrord/config/src/config\ has been restructured to use a new \MirrordConfigSource\ trait and \ConfigContext\ for managing environment overrides, strict isolation, and deprecation/unstable warnings. This change introduces dedicated modules for handling environment variable sources (\from\_env.rs\), fallback logic (\source.rs\), and warning aggregation for deprecated or unstable fields (\deprecated.rs\, \unstable.rs\), ensuring that config verification and generation are isolated from the process environment when needed and that users are properly warned about legacy or experimental settings.
mirrord/config/src/config · medium confidence
Refactored connection handling to support HTTP passthrough and mirroring
The agent's incoming connection logic has been restructured to introduce explicit passthrough and mirroring modes for both HTTP and TCP traffic. New modules (\body\_utils\, \copy\_bidirectional\, \optional\_broadcast\) provide the underlying infrastructure for bidirectional data copying and efficient frame handling, while \http.rs\ and \tcp.rs\ now expose \steal\, \mirror\, and \pass\_through\ entry points. This change enables the agent to forward requests to the original destination (passthrough) while simultaneously capturing the traffic for mirroring, a capability required by recent HTTP filtering and body filter features.
mirrord/agent/src/incoming/connection · high confidence
Refactored incoming connection handling with dedicated redirector and task components
The agent's incoming traffic management has been restructured to support more flexible connection interception. A new \ComposedRedirector\ allows chaining multiple inner redirectors (e.g., for IPv4 and IPv6), ensuring that failures in one do not leave dangling redirections in another. The \IpTablesRedirector\ now supports dynamic chain names and mesh exclusions, enabling targeting of multiple containers within the same pod. Connection handling is now managed by a central \RedirectorTask\ that coordinates \StealHandle\ and \MirrorHandle\ instances, allowing for concurrent stealing and mirroring of TCP and HTTP traffic. The \ConnectionInfo\ struct now includes logic for \passthrough\_original\_dst\ to fix issues where applications listen on external IPs, and \TCP\_NODELAY\ is explicitly set on all proxying sockets to reduce latency.
mirrord/agent/src/incoming · high confidence
Refactored incoming proxy with improved HTTP handling and TCP performance
The incoming proxy module has been restructured into dedicated components (bound\_socket, http, http\_gateway, tcp\_proxy, tls, etc.) to support more robust traffic interception. Key improvements include setting TCP\_NODELAY on local proxy sockets to reduce latency for intercepted connections, enabling HTTP/1.1 and HTTP/2 upgrades for stolen requests, and adding support for TLS delivery with client certificate authentication for mutual TLS scenarios. The proxy now handles HTTP version mismatches more gracefully, rejects HTTP/2 CONNECT requests to HTTP/1 servers, and supports filtered HTTP mirroring with version negotiation for older agents.
mirrord/intproxy/src/proxies/incoming · high confidence
Refactored network configuration into modular DNS, filter, incoming, and outgoing components
The network feature configuration has been restructured into distinct modules (\dns.rs\, \filter.rs\, \incoming.rs\, \outgoing.rs\) to improve clarity and maintainability. This change introduces a dedicated \AddressFilter\ and \ProtocolFilter\ system for precise traffic matching, allowing users to define filters by port, socket address, subnet, or hostname. DNS resolution is now explicitly configurable via \feature.network.dns.filter\ to route queries locally or remotely, with automatic synchronization to outgoing filters. Incoming traffic supports advanced mode with HTTP filtering, port mapping, and listen ports, while outgoing traffic allows fine-grained control over TCP/UDP and Unix streams. The refactoring ensures that hostnames in outgoing filters are automatically mirrored to DNS filters to keep resolution consistent with the connection side.
mirrord/config/src/feature/network · high confidence
Refined default file system routing for local and remote modes
The default behavior for file access in mirrord has been updated to improve compatibility and security. System configuration files such as \/etc/ssl/certs\, \/etc/resolv.conf\, \/etc/hosts\, and \/etc/hostname\ are now read from the remote target by default to ensure correct network resolution and SSL trust. Service account tokens located in \/run/secrets\ and \/var/run/secrets\ are also routed remotely to maintain proper authentication. Conversely, a broader set of local paths—including standard system directories (\/usr\, \/lib\, \/etc\), user home contents, temporary files, and specific file extensions (\.py\, \.rb\, \.sh\, \.so\, etc.)—are now read locally by default. Additionally, hidden files in the user's home directory are excluded from remote access unless explicitly configured, and paths under \/Program Files\ are forced local to support WSL debugging.
mirrord/layer-lib/src/file/unix · high confidence
Removal of initial VS Code extension entry point
The initial \src/extension.ts\ file, which served as the entry point for the VS Code extension, has been removed. This file previously handled extension activation by logging a confirmation message and setting up a debug session listener to execute an external shell script (\bintest.sh\) when the \mirrord\ configuration was present. Its deletion indicates that the extension's core activation logic or structure has been refactored or replaced.
src · high confidence
TLS connection stealing now supports configurable server name verification
The TLS handler in the mirrord agent now allows specifying a server name for verifying the original destination when the stolen connection lacks an SNI extension. This change introduces new error types for setup failures (such as invalid server names or certificate issues) and updates the handler logic to prioritize the configured server name, falling back to the request URI or original destination IP if necessary. This ensures more robust TLS passthrough for connections where the SNI is missing or ambiguous.
mirrord/agent/src/incoming/tls · high confidence
Unified socket layer with remote DNS and hostname resolution
The socket interception logic in the layer library has been restructured into a unified, cross-platform implementation supporting both Unix and Windows. This change introduces remote DNS resolution via the proxy (replacing local lookups for configured domains) and adds the ability to fetch the remote hostname and Samba NetBIOS configuration from the target environment. It also implements a mechanism to share socket state between parent and child processes spawned via exec, ensuring continuity of intercepted connections across process boundaries.
mirrord/layer-lib/src/socket · high confidence
Windows command resolution now supports .cmd and .bat shims
On Windows, the tooling now correctly locates and executes external programs installed as \.cmd\ or \.bat\ shims (such as \npm\, \pnpm\, or \corepack\). Previously, standard command spawning failed to find these scripts because it only appended \.exe\. The new \resolve\_command\ helper searches the \PATH\ using \PATHEXT\ rules, ensuring that shell-compatible scripts are resolved just as they would be in a standard command prompt or PowerShell session. This change also includes tests to verify correct behavior when multiple extensions are present in \PATHEXT\.
mirrord/command · high confidence
Windows crash and initialization diagnostics now report accurately and race-free
The Windows layer's crash reporting mechanism has been rewritten to ensure reliability and accuracy. The new implementation uses a shared-memory channel that allows the layer to signal crashes and initialization failures to the monitor without allocating memory or opening handles during the crash path, making it safe to call from crash handlers. This change eliminates previous race conditions during layer startup and ensures that initialization failures are correctly reported rather than being misinterpreted as clean shutdowns. Additionally, the monitor now distinguishes between actual crashes, init failures, and clean exits, providing more precise diagnostic data for troubleshooting.
mirrord/utils-win/src/diagnostics/monitor · high confidence
Windows layer hook initialization and crash filter management
The Windows mirrord layer now initializes its API hooks (process, file system, socket, and exception handling) via a centralized \initialize\_hooks\ function that creates all detours in a disabled state before enabling them atomically. This ensures that if any hook setup fails, no functions are patched, leaving the target process untouched. Additionally, when crash reporting is enabled, the layer installs its own unhandled exception filter to capture crashes, specifically hooking \SetUnhandledExceptionFilter\ to prevent the target's runtime from overriding it, while preserving the original filter in the chain.
mirrord/layer-win/src/hooks · high confidence
Windows layer injection switches to Stork and enforces stricter linting
The Windows layer now uses the Stork library for DLL injection instead of the previous dll-syringe approach, with a build script that configures MSVC-specific export markers for the injection mechanism. Additionally, a dedicated clippy configuration bans unsafe macros and methods (such as std::print and std::thread::current) that could cause thread handle slot conflicts or process termination issues within the layer, ensuring safer execution on Windows.
mirrord/layer-win · high confidence
Windows process execution and layer injection overhaul
The Windows layer now uses a new \stork\ library for DLL injection, replacing the previous \dll-syringe\ approach, and introduces configurable injection methods (LoadLibrary, APC, IAT) via the \MIRRORD\_INJECTION\_METHOD\ environment variable. Process creation and environment handling have been rewritten to strictly follow Windows naming rules, ensuring correct command-line quoting and case-insensitive environment variable merging. A race-free, named-event synchronization mechanism replaces the previous init handshake, allowing the launcher to reliably detect layer readiness or failure. Additionally, child processes are now managed via Windows Job Objects to ensure proper cleanup, and a new \MIRRORD\_LAYER\_WAIT\_FOR\_DEBUGGER\ variable allows pausing specific processes for debugger attachment during initialization.
mirrord/layer-lib/src/process · high confidence
get\_skill tool now returns markdown text instead of structured output
The get\_skill tool in the MCP server has been updated to return skill content as raw markdown text rather than a structured format. This change affects how skill details and associated files are presented to users, providing a more direct text representation of the skill's content and its referenced files.
_mirrord/mcp/src/tools/get\skill · high confidence
Test coverage
3 commits adding/updating tests in mirrord/sessions-manager; Added Kafka consumer test harness for split-topic validation; Added Rust end-to-end tests for file operations; Added Rust-based SQS printer test utility; Added WebSocket echo test harness; Added integration test applications for Windows layer support; Added integration test applications for layer validation; Added integration tests for CI credential handling; Added integration tests for the MCP server; Added integration tests for the session monitor API; Added local test server for issue 1317; Added macOS DNS-SD test application; Added regression test for Go syscall truncation on Linux arm64; Added smoke tests for TUI layout and shell interaction; Added test app for duplicate listener descriptor behavior; Added test application for Windows command execution hooks; Added test for environment preservation during SIP-patched exec on macOS; Added test for posix\_spawn shared socket behavior; Added test utilities for TCP and HTTP steal scenarios; Added tests for Windows layer startup and process inspection; Added tests for the validate\_config tool; Expanded integration test coverage for layer behavior and platform-specific edge cases; New E2E test infrastructure and Go-based test applications; New shared test utilities and application definitions for integration tests; New test harness for the internal proxy (intproxy); New test utilities for managing mirrord test processes; Removed legacy VS Code test runner and sample tests.
Dependencies
Workspace dependency management and new internal crates
The project has restructured its Rust dependencies to use workspace-level inheritance, centralizing version management across the monorepo. This change introduces several new internal crates to support this structure and specific features: \medschool\ for documentation extraction, \mirrord-agent-env\ for agent environment configuration, \mirrord-agent-iptables\ for Linux-specific network rules, and \mirrord-config-derive\ for configuration macro generation. Additionally, Go test application dependencies have been updated, including \app\_go\ moving to Go 1.21 and \issue2988\ to Go 1.23.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 54 → 58 (+3.3)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 48 → 52 (+4.4)
- Architecture 93 → 92 (-0.3)
- Maturity 77 → 79 (+1.8)
- Readiness 54 → 57 (+2.4)
- Security 64 → 61 (-2.1)
- Event Sourcing 100 → 100 (+0.0)
- Accessibility 56 → 64 (+7.3)
- Performance 70 → 70 (+0.0)
Resolved (89)
- Change coupling: incoming.rs ↔ outgoing.rs (mirrord/config/src/feature/network/incoming.rs)
- Duplicated block (10 lines × 2) (mirrord/cli/src/extension.rs)
- Duplicated block (10 lines × 2) (mirrord/cli/src/port_forward.rs)
- Duplicated block (10 lines × 2) (mirrord/layer/src/file/hooks.rs)
- Duplicated block (10 lines × 2) (mirrord/tui/src/screens/targets/browser.rs)
- Duplicated block (11 lines × 2) (mirrord/operator/src/client.rs)
- Duplicated block (11 lines × 2) (mirrord/operator/src/client.rs)
- Duplicated block (12–13 lines × 4) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (13 lines × 2) (mirrord/agent/src/steal/api.rs)
- Duplicated block (13 lines × 2) (mirrord/operator/src/crd.rs)
- Duplicated block (13–14 lines × 4) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (14 lines × 2) (mirrord/tui/src/screens/databases.rs)
- Duplicated block (14 lines × 2) (xtask/src/tasks/cli.rs)
- Duplicated block (14–15 lines × 2) (mirrord/layer/macro/src/lib.rs)
- Duplicated block (14–15 lines × 2) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (15 lines × 2) (mirrord/kube/src/resolved.rs)
- Duplicated block (15 lines × 2) (xtask/src/tasks/layer.rs)
- Duplicated block (15 lines × 3) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (17 lines × 2) (mirrord/layer/macro/src/lib.rs)
- Duplicated block (20–22 lines × 2) (mirrord/cli/src/preview.rs)
- …and 69 more
New (242)
- (anonymous) (cyclomatic 16) (packages/wizard/mock-server.js)
- Change coupling: connection.rs ↔ extract.rs (mirrord/cli/src/connection.rs)
- Change coupling: credential_store.rs ↔ config.rs (mirrord/auth/src/credential_store.rs)
- Change coupling: extension.rs ↔ extract.rs (mirrord/cli/src/extension.rs)
- Changes::merge (cognitive 20) (mirrord/cli/src/preview/sync.rs)
- Critical CVE: [GHSA redacted] (Cargo.lock)
- Duplicated block (10 lines × 2) (mirrord/tui/src/screens/targets/browser.rs)
- Duplicated block (10 lines × 3) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (11 lines × 2) (mirrord/agent/src/entrypoint.rs)
- Duplicated block (11 lines × 2) (mirrord/cli/src/port_forward.rs)
- Duplicated block (11 lines × 2) (mirrord/layer/src/file/hooks.rs)
- Duplicated block (11 lines × 2) (mirrord/operator/src/client.rs)
- Duplicated block (11 lines × 2) (mirrord/operator/src/client.rs)
- Duplicated block (11–14 lines × 2) (mirrord/operator/src/client/preview_sync.rs)
- Duplicated block (12 lines × 2) (mirrord/agent/src/steal/api.rs)
- Duplicated block (12 lines × 2) (mirrord/layer/src/file/hooks.rs)
- Duplicated block (12–13 lines × 4) (mirrord/operator/src/client/database_branches.rs)
- Duplicated block (12–15 lines × 2) (mirrord/tui/src/screens/databases.rs)
- Duplicated block (13 lines × 2) (mirrord/operator/src/crd.rs)
- Duplicated block (14 lines × 2) (mirrord/tui/src/screens/databases.rs)
- …and 222 more
Changes since last survey
- 208 commits — 196 feature/other, 12 fixes
By area
- (repo) — 52 commits
- mirrord/cli — 47 commits
- mirrord/operator — 23 commits
- (root) — 19 commits
- mirrord/up — 12 commits
- .github/workflows — 8 commits
- mirrord/mcp — 7 commits
- mirrord/agent — 4 commits
- mirrord/config — 4 commits
- mirrord/layer-lib — 4 commits
- mirrord/layer-tests — 3 commits
- changelog.d/+preview-code-sync.added.md — 2 commits
- changelog.d/+up-mode-db-branching.added.md — 2 commits
- packages/wizard — 2 commits
- .greptile/config.json — 1 commit
- changelog.d/+dirty-iptables-fixture-lifetime.internal.md — 1 commit
- changelog.d/+dirty-iptables-released-agent-image.internal.md — 1 commit
- changelog.d/+dump-target-container-ports.changed.md — 1 commit
- changelog.d/+e2e-test-app-retries.internal.md — 1 commit
- changelog.d/+faster-ci.internal.md — 1 commit
Notable commits
- fix: Enable Linux filesystem interception fixes by default for OSS
- fix: Enable linux fs fixes for all users (#5214)
- fix: Fix serverless exec progress (#5229)
- fix: Fix stale CI and contributing docs
- fix: Merge branch 'main' into meowchinist/cor-2101-fix-flaky-test-mirrord
- fix: Merge pull request #5170 from metalbear-co/meowchinist/cor-2101-fix-flaky-test-mirrord
- fix: Revert "Enable linux fs fixes for all users" (#5226)
- fix: Update libz-sys to fix cargo-deny advisory
- fix: cli: show how to fix each failed service of preview up/preview sync
- fix: fix(layer): keep ancestors local only to calls that describe them
- fix: fix(tests): retain dirty iptables namespace through assertions
- fix: fix(up): keep forwarding a service's output past bytes that aren't UTF-8
- change: Add KubeCon Salt Lake City raffle information (#5205)
- change: Add the MultiClusterQueueSplitRole operator feature (INT-566) (#5192)
- change: Add the share link port to the preview status
- change: Allow Redis branches without location in the schema (#5198)
- change: Baggage in mirrord up common config (#5196)
- change: Bump libz-sys to 1.1.31 for RUSTSEC-2026-0418
- change: Bump pulldown-cmark to 0.13.5 for RUSTSEC-2026-0414
- change: Cap the CI runner build cache on the Blacksmith sticky disks (#5202)
- …and 188 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
metalbear-co/mirrord 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.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 77c2d33dce64baeb07d9ce037bf1a0ba7001accc — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.