warp-tech/warpgate

Warpgate is a secure remote access gateway that proxies and secures connections to SSH, HTTP, Kubernetes, MySQL, PostgreSQL, RDP, and VNC targets. It provides a unified web interface for session management, featuring granular role-based access control, multi-factor authentication, and just-in-time approval workflows. The system supports centralized configuration via database or LDAP, integrates with external secret backends like HashiCorp Vault, and maintains comprehensive audit trails with session recording capabilities.

48 changes.

This period focused on significantly enhancing security through granular role-based access control, encryption at rest, and comprehensive audit logging, while removing legacy file-based configuration and Svelte-based admin interfaces. The project expanded its protocol support by introducing MySQL proxying and robust HTTP session management, alongside a major refactoring of the SSH client and server to improve reliability and add jump host support. Concurrently, the web interface was modernized with Svelte 5 and Vite, introducing self-service ticketing, MFA enforcement, and detailed session recording playback capabilities.

37 changes.

This period focused on significantly expanding protocol support by adding native implementations for PostgreSQL, Kubernetes, RDP, and VNC, alongside comprehensive web-based clients for SSH and remote desktops. The admin interface underwent a major restructuring to support these new targets, introducing granular role management, LDAP synchronization, and centralized session monitoring. Underlying infrastructure improvements included a new rate-limiting subsystem, Helm chart release, and enhanced TLS and certificate management capabilities.

Administrators can now configure secret backends to resolve passwords and private keys from HashiCorp Vault or OpenBao. The new Secret Backends page in the admin UI allows creating, editing, and deleting backend configurations, supporting Token, AppRole, and Kubernetes authentication methods. The backend enforces allowed KV path prefixes, handles token renewal, and displays health status for each configured backend.

warpgate-secrets-vault, warpgate-web/src/admin/config/secret-backends · high confidence

This change introduces a new MySQL protocol server (\MySQLProtocolServer\) and client implementation within the \warpgate-protocol-mysql\ crate, enabling Warpgate to proxy MySQL database connections. The implementation handles the full MySQL handshake, including TLS negotiation and authentication via \mysql\_native\_password\ and \caching\_sha2\_password\ plugins. It also features a \ResponseRelay\ component that rewrites MySQL protocol packets to reconcile capability mismatches (such as \DEPRECATE\_EOF\ and \SESSION\_TRACK\) between the client and the backend target, ensuring compatibility across different MySQL server versions.

warpgate-protocol-mysql · high confidence

Introduces a new PostgreSQL protocol server and client implementation, enabling Warpgate to proxy PostgreSQL database connections. The feature includes support for TLS negotiation and upgrade, multiple authentication methods (cleartext password, MD5, and SASL), and configurable protocol versions (defaulting to 3.2). It also handles connection keepalive settings and integrates with the existing session management and web approval workflows.

warpgate-protocol-postgres · high confidence

This change introduces a new VNC protocol implementation, allowing users to connect to VNC targets through the platform. The \warpgate-protocol-vnc\ module provides both a browser-compatible client path (using Tight, Zrle, and other encodings for in-browser rendering) and a native proxy path (decoding and re-encoding video streams for recording or native viewers). It includes the server binding logic, client connection handling, and input mapping (pointer, keyboard, wheel, clipboard) to integrate VNC sessions into the existing desktop access framework.

warpgate-protocol-vnc/src, warpgate-protocol-vnc/src/server · high confidence

This change introduces a new MySQL database protocol implementation within the \warpgate-database-protocols\ crate. It adds the necessary low-level protocol logic to support MySQL connections, including character set and collation definitions, length-encoded integer/string encoding, and the full connection handshake sequence (handshake, SSL request, and handshake response). It also implements the \caching\_sha2\_password\ authentication plugin alongside other standard MySQL auth methods, enabling users to connect to MySQL databases that require this specific authentication mechanism.

warpgate-database-protocols · high confidence

A new \.well-known/funding-manifest-urls\ file has been added to the repository, pointing to \https://null.page/funding.json\. This allows external tools and platforms to discover the project's funding information via the standard well-known URI path.

.well-known · high confidence

A new Docker Compose setup in docker/local-testing/login-protection allows users to locally test the built-in brute-force protection feature. This environment includes scripts to verify IP blocking, user account lockout, and exponential backoff behaviors, along with an admin API for manually unblocking IPs and unlocking users.

docker/local-testing · high confidence

Administrators can now create, view, edit, and delete target groups directly from the web interface. This adds a dedicated section under configuration where groups are listed with natural sorting, and each group can be assigned a name, description, and an optional color for visual organization. The new components enforce admin permissions for creating, editing, and deleting groups, and provide a form-based interface for managing these settings.

warpgate-web/src/admin/config/target-groups · high confidence

The system now includes a centralized login protection service that enforces IP rate-limiting and user account lockouts based on configurable thresholds. This feature introduces an in-memory cache for fast read-path checks of blocked IPs and locked users, while tracking failed attempts to automatically block source IPs or lock user accounts after repeated failures. It also supports case-insensitive username matching to prevent enumeration attacks and ensures that admin accounts are exempt from automatic lockouts to prevent denial-of-service against administrators.

warpgate-core/src · high confidence

Warpgate now supports storing configuration in a PostgreSQL database via the new \DatabaseConfigProvider\. This change introduces a new module in \warpgate-core/src/config\_providers\ that implements the \ConfigProvider\ trait to manage users, targets, credentials, and authorization policies directly from the database. It includes specific logic for synchronizing LDAP SSH keys, resolving SSO users, and applying SSO role and admin-role mappings, allowing administrators to move away from file-based configuration for these entities.

_warpgate-core/src/config\providers · high confidence

The \warpgate-db-entities\ module now provides the persistent data models that underpin Warpgate's security and access features. This includes granular Admin Roles with specific permission flags, distinct credential types (password, public key, TOTP, certificate, and SSO) linked to users, and configurable Access Roles with default assignment logic. The schema supports self-service Ticket Requests for just-in-time access, session approval workflows with status tracking, and brute-force protection via IP blocking and failed login attempt logging. Additionally, it introduces Target Groups for interface organization, configurable session parameters (such as MFA enforcement and SSH host key verification), and cluster node registration for cross-node proxying.

warpgate-db-entities · high confidence

The admin log viewer now displays access roles, admin roles, targets, and users as clickable badges that link directly to their respective configuration pages (with targets and users requiring edit permissions). Additionally, administrators can now download the full log history via a new export button, and the view supports virtualization and a 500-row memory cap for improved performance.

warpgate-web/src/admin/log-viewer · high confidence

This change introduces the first version of the Warpgate Helm chart, providing a complete Kubernetes deployment manifest set. It includes templates for the main Deployment, Service (with configurable ports and LoadBalancer source ranges), Ingress, and optional HTTPRoute resources. The chart manages the application lifecycle via a setup Job or pod-init container, handles configuration through ConfigMaps and environment variable substitution, and supports bundled PostgreSQL via a StatefulSet. It also includes logic for TLS certificate management (using provided secrets or generating self-signed ones) and SSH key handling, ensuring the admin user is created and configuration is applied during installation.

helm/warpgate, helm/warpgate/templates · high confidence

The warpgate-ldap module has been added to provide LDAP user synchronization capabilities. This new component enables Warpgate to connect to LDAP directories (supporting StartTLS and LDAPS), authenticate via bind credentials, and automatically discover base DNs. It allows administrators to configure username attributes (such as cn, uid, or sAMAccountName) and UUID attributes to map LDAP users to Warpgate accounts, including the extraction of SSH public keys and email addresses.

warpgate-ldap · high confidence

This change introduces the core implementation for Remote Desktop Protocol (RDP) support within Warpgate. It adds a new \warpgate-protocol-rdp\ module that provides both a server-side endpoint for native RDP clients (like mstsc) to connect to and a client-side bridge to connect to remote targets. A key feature included in this initial implementation is clipboard redirection, allowing text to be copied and pasted between the local machine and the remote desktop session, with specific handling for Unicode text formats and size limits.

warpgate-protocol-rdp/src · high confidence

RDP and VNC viewers now support interactive second-factor authentication (TOTP and web approvals) directly within the desktop session. After entering a valid password, the client displays a holding screen that collects the second factor before connecting to the target, including support for web-approval bypasses and brute-force protection for OTP attempts.

warpgate-desktop-auth · high confidence

Adds the \warpgate-protocol-http\ module, implementing the HTTP proxy protocol server. This includes an admin approval gate that presents an interstitial page for pending sessions, a database-backed session storage system for cross-node session persistence, and an HTTP client cache to reuse connections to upstream targets. The implementation handles request routing, WebSocket proxying, and session lifecycle management specific to the HTTP protocol.

warpgate-protocol-http/src · high confidence

Adds a new web-based remote desktop client supporting RDP and VNC protocols. The implementation introduces a WebSocket-based API for real-time session management, including input forwarding and keepalive handling. To optimize performance, the client uses progressive encoding: it sends initial updates as JPEGs for speed and refines settled areas into lossless PNGs, while also re-encoding raw framebuffer tiles to reduce bandwidth. A dirty-rect tracking system manages these refinements, and the session manager handles connection state, clipboard redirection, and desktop recording.

warpgate-web-desktop · high confidence

This change adds new foundational modules to warpgate-common that enable secure API access, credential protection, and comprehensive audit trails. The api module defines security schemes for authenticating API requests via the X-Warpgate-Token header or the warpgate-http-session cookie. The encryption module implements AES-256-GCM encryption at rest for credentials, managed via the WARPGATE\_ENCRYPTION\_KEY environment variable, supporting key rotation through a keyring of primary and retired keys. The audit module introduces a rich set of structured audit events, including detailed tracking for Kubernetes operations (exec, attach, port-forward, debug containers), credential lifecycle changes, user/role management, and session activities. Additionally, the secrets module provides a unified interface for resolving secrets from HashiCorp Vault or OpenBao backends, and the error module standardizes user-facing error messages to prevent information leakage.

warpgate-common/src · high confidence

Adds a new rate-limiting subsystem in warpgate-core that enforces bandwidth quotas on data streams. The system supports three distinct limit tiers—global, per-user, and per-target—which are stacked so that the most restrictive quota applies to the connection. Limits are sourced from the database (user and target entities, plus global parameters) and can be swapped dynamically at runtime via a registry that refreshes quotas and updates active sessions without dropping connections. The implementation uses the \governor\ library for token-bucket rate limiting and includes a \RateLimitedStream\ wrapper that applies jittered waits to async I/O operations to enforce the configured bytes-per-second limits.

_warpgate-core/src/rate\limiting · high confidence

This change adds the foundational types and logic for handling graphical desktop (RDP/VNC) and terminal sessions within the core protocol layer. It introduces a unified event and input model (\DesktopEvent\, \DesktopInput\) that normalizes backend protocols into a common format for the browser renderer and recording system, including support for clipboard redirection and logon-state tracking. A server-side framebuffer implementation is added to reconstruct and snapshot remote desktop deltas into PNGs for recordings and live viewer synchronization. Additionally, a terminal screen abstraction is provided to render and snapshot VT100 terminal output, ensuring safe resizing and state preservation.

warpgate-core/src/protocols · high confidence

This change introduces the Kubernetes protocol implementation within the warpgate-protocol-kubernetes module. It adds a request correlator that groups concurrent kubectl requests into a single session to trigger only one web approval, and an audit classifier that records Kubernetes API operations (exec, attach, port-forward, debug) into session logs and terminal recordings. The module also includes a recorder for capturing API request/response pairs and session metadata, along with the protocol server binding logic.

warpgate-protocol-kubernetes/src · high confidence

The Kubernetes protocol server now accepts client TLS certificates as a transport credential for authenticating users. This change introduces a custom TLS acceptor that captures client certificates during the handshake and a middleware that extracts them for request processing. The authentication logic in \auth.rs\ now validates these certificates against the Warpgate credential database, allowing users to authenticate using certificates in addition to existing methods like API tokens and OIDC. This enables certificate-based identity verification for Kubernetes API requests proxied through Warpgate.

warpgate-protocol-kubernetes/src/server · high confidence

The admin interface now includes a dedicated section for managing LDAP servers. Administrators can create, edit, and delete LDAP server configurations, specifying connection details, TLS settings, and attribute mappings for usernames, SSH keys, and UUIDs. A connection test feature allows verifying connectivity before saving. Additionally, a user browser enables administrators to load users from the configured LDAP directory and batch-import them into Warpgate, automatically syncing their SSH keys.

warpgate-web/src/admin/config/ldap · high confidence

Warpgate now accepts direct TCP connections from standard RDP clients (such as mstsc or FreeRDP) via a new native RDP server endpoint. This feature introduces a viewer-facing RDP server that terminates TLS and bridges the connection to the authenticated target, enabling users to access desktops using their native RDP tools. The implementation includes support for dynamic client resize requests, bidirectional clipboard redirection, and session recording that mirrors the in-browser experience. Additionally, it features an interactive hold screen for second-factor authentication (TOTP or web approval) and displays compliance banners before the session begins.

warpgate-protocol-rdp/src/server · high confidence

The \warpgate-desktop-ui\ crate now provides a native desktop rendering library for the session hold screens displayed to RDP and VNC clients. It renders a connecting state, a login banner, and authentication prompts (including web approval with security keys and OTP entry) using the \embedded-graphics\ framework. This replaces previous terminal-based or placeholder visuals with a dedicated UI that includes the Warpgate logo, an animated bouncy ball, and formatted text, ensuring users see a consistent and branded experience while waiting for admin approval or entering credentials.

warpgate-desktop-ui · high confidence

The warpgate-aws crate introduces native support for several AWS services. It adds EC2 capabilities including environment detection via IMDS, instance lookup by IP across regions, and SSH key injection via EC2 Instance Connect. EKS support allows finding clusters by API server URL and generating authentication tokens for cluster access. RDS integration provides IAM-based authentication token generation. Finally, S3 support enables recording storage with configurable credentials (auto or static), support for S3-compatible endpoints, and multipart upload handling.

warpgate-aws · high confidence

The \warpgate\ CLI now includes several new commands to simplify administration and maintenance. Administrators can use \copy-database\ to migrate configuration and user data to a new database, \migrate-database\ to manually apply or revert database schema changes, and \create-user\ to provision new users with optional role assignments. A \healthcheck\ command allows external systems to verify the service's availability, while \recover-access\ provides an interactive way to reset a user's password and restore login capability. The \check\ command has been expanded to validate TLS certificates and keys for HTTP, MySQL, and PostgreSQL listeners, and the \setup\ process now supports unattended mode and SSH key import flags.

warpgate/src/commands · high confidence

The warpgate-ca crate introduces a dedicated library for managing X.509 certificates and TLS identities. It provides functionality to issue a root CA certificate, generate client certificates signed by that CA, and create specific cluster peer TLS identities (using the SNI name warpgate-cluster.internal) for inter-node communication. The library handles certificate serialization/deserialization (PEM/DER), computes SHA256 fingerprints for peer verification, and defines a comprehensive error type (CaError) covering X.509, ASN.1, and cryptographic operations.

warpgate-ca · high confidence

The HTTP protocol layer now includes four new middleware components that change how requests are processed. CookieHostMiddleware automatically scopes the session cookie to a configured base domain (including subdomains) and enforces Secure/SameSite=None attributes for HTTPS, while removing the domain attribute for localhost to fix cross-domain cookie handling. MfaEnforcementMiddleware blocks access to proxied targets and admin APIs for users who have not completed MFA setup, allowing only essential enrollment and login endpoints. ContentSecurityPolicyMiddleware adds a strict Content-Security-Policy header to responses if one is not already present, preserving any existing policy set by specific endpoints like the playground. TicketMiddleware enables authentication via header-borne or query-string tickets, creating temporary, non-persisted sessions for ticket-based access.

warpgate-protocol-http/src/middleware · high confidence

This change introduces the \warpgate-common-http\ library, providing core HTTP request processing capabilities. It adds structured authentication context (\auth.rs\) that supports session and token-based authorization, including a new mechanism to enforce re-authentication policies based on session age. It also includes robust error handling (\errors.rs\) that sanitizes internal server errors from client responses by replacing raw stack traces with user-friendly messages and correlation IDs, preventing information leakage. Additionally, it implements secure parsing of \X-Forwarded-\*\ headers (\request.rs\) to correctly identify client IPs and hostnames behind proxies, and defines Content Security Policy configurations (\lib.rs\) to harden the application against XSS and other web vulnerabilities.

warpgate-common-http · high confidence

This change introduces the warpgate-sso module, enabling Single Sign-On via OIDC providers (Google, Apple, Azure, and custom). Users can now configure role mappings for Google groups and custom providers, specify custom group claims, and enable auto-creation of SSO users. The module supports Kubernetes target authentication via kubelogin and allows configuring return URL domains and prefixes. Security improvements include validation of OIDC discovery endpoint schemes to prevent XSS, verification of the OIDC state parameter, and support for additional trusted audiences. Error logging for SSO discovery and OIDC server errors has been enhanced for better troubleshooting.

warpgate-sso · high confidence

The admin configuration interface now includes dedicated pages for managing access roles (granting users access to targets), admin roles (defining permissions for administrators with dependency-aware permission toggles), and SSH client keys (importing, generating, and referencing keys via Vault/OpenBao). These changes restructure the admin config area with a new sidebar navigation and route definitions, allowing administrators to create, edit, and delete these resources directly from the web UI.

warpgate-web/src/admin/config · high confidence

The admin interface now includes a new application shell (App.svelte) that manages routing and displays a modal prompting administrators to configure installation analytics (off, reduced, or normal) upon first login. The UI also introduces new credential management modals: CertificateCredentialModal for generating and downloading ECDSA key pairs and certificates (including Kubernetes kubeconfig generation), CreateOtpModal for setting up TOTP 2FA with QR code validation, CreatePasswordModal with real-time password policy enforcement feedback, PublicKeyCredentialModal with automatic label extraction on paste, and SsoCredentialModal for managing SSO provider credentials. Additionally, the Log page now supports filtering by user, access role, or admin role, and the VNC target configuration options have been added.

warpgate-web/src/admin · high confidence

The admin interface now includes dedicated players for desktop and terminal session recordings, enabling users to review past sessions with precise, fast seeking. These players utilize an index file (index.ndjson) to jump directly to keyframes rather than replaying linearly, and support live tailing for active sessions. The desktop player renders framebuffer updates on a canvas and overlays viewer input events (clicks, keypresses), while the terminal player replays raw terminal bytes into an xterm instance with a custom theme. Both players share a common playback controller and range-stream implementation that handles HTTP Range requests and WebSocket live streams, ensuring efficient memory usage and responsive scrubbing.

warpgate-web/src/admin/player · high confidence

This change introduces a new recording module for desktop sessions (RDP/VNC) alongside the existing terminal recordings. The new \desktop.rs\ module captures framebuffer updates as PNG/JPEG deltas and input events (keyboard, mouse, clipboard) into an NDJSON stream, mirroring the live web-desktop message format for seamless playback. It includes a frame-rate capping mechanism to prevent core pinning during busy sessions. The recording infrastructure (\storage.rs\, \writer.rs\) now supports both local disk and Amazon S3 backends, with S3 uploads using multipart streaming and local scratch files. The \traffic.rs\ module was refactored to support Unix socket forwarding in addition to TCP, and the overall recording system now uses a unified \RecordingWriterOpener\ and \Recorder\ trait for better modularity.

warpgate-core/src/recordings · high confidence

This change introduces the embedded user interface component (EmbeddedUI.svelte) and its entry point (index.ts) for the warpgate-web application. The embedded UI provides a floating, draggable menu icon that allows users to navigate home or log out, with its position persisted in local storage. It also includes logic to force WebSocket connections to use the secure wss:// protocol, ensuring compatibility when proxying non-secure HTTP targets. Additionally, the entry point unregisters any existing service workers to prevent caching conflicts.

warpgate-web/src/embed · high confidence

The admin API now exposes dedicated endpoints for managing fine-grained admin roles and enforcing permission-based access control. A new \/admin-roles\ API allows administrators to create, read, update, and delete custom roles with specific permissions (e.g., \targets\_create\, \users\_edit\, \sessions\_terminate\). The authentication layer has been updated to use a structured \AdminContext\ that resolves the caller's permission set from the database, ensuring that API handlers can explicitly require specific permissions via \admin.require()\. This replaces the previous binary admin check with a detailed, auditable permission model.

warpgate-admin/src/api · high confidence

The admin interface now includes a dedicated /status section that consolidates session management, JIT approval requests, login protection, and network diagnostics into a single navigable area. This update introduces new pages for viewing and terminating active sessions, approving or rejecting JIT session and ticket requests, managing blocked IPs and locked users, and inspecting protocol listeners and client IP detection. It also adds a new Kubernetes recording viewer for inspecting API request/response payloads and links to user/target details from the session view.

warpgate-web/src/admin/status · high confidence

The web client now includes a dedicated library in warpgate-web/src/gateway/lib to manage core connectivity and user preferences. This introduces a ReconnectingWebSocket utility that handles WebSocket connections with exponential backoff and binary frame support, essential for stable Web SSH and Web Desktop sessions. It also adds a certificate store using IndexedDB for persisting SSH keys and a session opener that respects the new 'open targets in new tab' preference, allowing users to configure whether SSH and desktop targets open in new browser tabs or the current window.

warpgate-web/src/gateway/lib · high confidence

The admin interface now includes a dedicated configuration panel for RDP targets, allowing users to set connection details (host, port), authentication credentials (username, domain, password), and security settings. Key options include enabling interactive logon to show the target's sign-in screen, selecting TLS security levels (TLS 1.2, TLS 1.2 with legacy ciphers, or TLS 1.0), and choosing compression quality (Lossless or RemoteFX) between Warpgate and the target server.

warpgate-web/src/admin/config/targets/rdp · high confidence

The SSH target configuration UI in the admin panel has been updated to allow administrators to configure SSH jump hosts via a dropdown selector, enabling connections through intermediate SSH servers. Additionally, a new host key checker component has been added to the target options form, which allows admins to verify the remote server's SSH host key against known trusted keys, view the current key status (valid, unknown, or changed), and directly trust new keys from the interface.

warpgate-web/src/admin/config/targets/ssh · high confidence

The HTTP API now exposes endpoints for users to request access to targets via self-service tickets (creating, viewing, and activating requests) and for managing personal API tokens (creating, listing, and deleting tokens with configurable expiry). These capabilities are implemented in the new \ticket\_requests\, \ticket\_request\_targets\, and \api\_tokens\ API modules, which handle the request lifecycle, target visibility for requests, and token storage/verification respectively.

warpgate-protocol-http/src/api · high confidence

Users can now manage their own credentials (passwords, public keys, OTP devices) and API tokens directly from the web interface, request self-service access tickets, and handle out-of-band authentication approvals. The login flow has been updated to support MFA setup enforcement, minimized password login modes, and automatic SSO redirection when only one provider is available.

warpgate-web/src/gateway · high confidence

Introduces a shared library for browser-based clients (SSH and desktop) that provides protocol-agnostic session handling. This includes a buffered outbound message queue that survives brief reconnects, a liveness flag, a disconnect grace timer to allow page reloads to reattach, and an in-memory registry of live sessions. This common plumbing ensures consistent behavior across different remote access protocols.

warpgate-web-clients-common · high confidence

The logging subsystem now supports structured log storage and machine-readable output. A new database logger layer captures audit and Warpgate events, serializing session details, usernames, and related roles into persistent log entries via Sea-ORM. Additionally, a JSON console layer emits structured JSON logs to stdout for both standard Warpgate events and audit events, facilitating easier log processing and integration with external monitoring tools.

warpgate-core/src/logging · high confidence

The vendor/ironrdp-server directory has been updated to include a comprehensive set of new source files implementing core RDP server functionality. This includes autodetection and RTT measurement logic, a builder pattern for server configuration, RDP capability negotiation, clipboard (Cliprdr) support, display update handling with framebuffer management, ECHO protocol support for round-trip time measurement, and encoders for bitmap, FastPath, and RemoteFX (RFX) compression. Additionally, the update introduces EGFX (Graphics Pipeline Extension) support for H.264 video streaming via DVC, input event handling for keyboard and mouse, and various utility modules for encoding and server state management.

vendor/ironrdp-server · high confidence

Users can now connect to SSH targets directly through a web browser. This change introduces the \warpgate-web-ssh\ module, which provides a WebSocket API for managing terminal sessions, handling client input, resizing, and host key verification. It includes session management to track active connections and integrates with the existing audit logging and recording systems to capture terminal activity.

warpgate-web-ssh · high confidence

The \file.rs\ configuration provider and the \mod.rs\ module containing the \ConfigProvider\ trait, \AuthResult\, and \AuthCredential\ types have been deleted from \warpgate-common/src/config\_providers\. This removes the ability to load user credentials, targets, and roles from local file-based storage, as well as the associated in-memory authorization logic for password and public key authentication that relied on this provider.

_warpgate-common/src/config\providers · high confidence

The entire legacy Svelte-based admin interface has been removed from the application. This includes the main application shell (App.svelte), all routing and page components (Home, Login, Session, Recording, Targets, Tickets, CreateTicket, SSH), and supporting library modules (api, ssh, store, time). The deletion of these files eliminates the previous client-side rendering layer and its associated Bootstrap-based styling (theme.scss, vars.scss).

warpgate-admin/app/src · high confidence

The \warpgate-admin/app\ directory has had its \index.html\ entry point, \vite.config.ts\ build configuration, \.eslintrc.yaml\ linting rules, and \openapi-schema.json\ API definition removed. This cleanup eliminates the local frontend build setup and static API schema from this location, likely as part of a migration to a different build system or project structure.

warpgate-admin/app · high confidence

The session recording subsystem in \warpgate-common\ has been removed. This deletes the \recordings\ module, including the \SessionRecordings\ orchestrator, \RecordingWriter\ for persisting data, and specific recorders like \TerminalRecorder\. Consequently, the system no longer captures or stores terminal session recordings or their associated database metadata.

warpgate-common/src/recordings · high confidence

The admin interface now uses Stoplight Elements for the API playground instead of Swagger UI, with adjusted Content Security Policy headers to allow asset loading. The server architecture has shifted from a standalone binary to a library function (\admin\_api\_app\) that returns a routed endpoint, enabling integration into the main application. New endpoints have been added for session approval workflows (\/session-approvals/changes\ stream) and cluster notifications, alongside recording data streams. The previous embedded static file serving and session-based authorization helpers have been removed in favor of this new modular API structure.

warpgate-admin/src · high confidence

The admin web interface introduces a new set of reusable UI components and a structured permission model. A sectioned form system (SectionedForm, Section, Subsection) now organizes complex configuration pages with sticky navigation tabs that track scroll position. A PermissionGate component enforces role-based access control by conditionally rendering content based on the admin's permissions, which are now explicitly defined in the store (covering targets, users, sessions, tickets, and configuration). The API client is centralized in api.ts with error handling improvements, and time formatting has been migrated to use date-fns.

warpgate-web/src/admin/lib · high confidence

The database module now handles connection setup for both SQLite (with WAL mode for concurrency) and other SQL databases, automatically applying schema migrations upon startup. It also implements automated cleanup routines that delete expired audit logs, session approval requests, and inactive ticket requests based on configurable retention periods, while ensuring session recordings are cleaned up when their parent sessions end.

warpgate-core/src/db · high confidence

This update introduces a comprehensive set of database migrations that restructure the storage layer to support new product capabilities. It adds tables for API tokens, audit log entries, and distinct credential models (OTP, password, public key, SSO) to enable self-service credential management and multi-factor authentication. The schema now supports role-based access control with target and user role assignments, LDAP server configuration with user synchronization, and target grouping for improved interface organization. Additionally, it introduces rate limiting columns, SSH client authentication toggles, and a built-in Certificate Authority (CA) for SSH host key management, while fixing column types for MySQL and PostgreSQL compatibility.

warpgate-db-migrations · high confidence

Warpgate now supports live-reloading of port listener configurations without requiring a full restart. A new \listener\_supervisor\ component monitors configuration changes and TLS certificate file updates on disk, automatically restarting the affected protocol listeners (SSH, HTTP, etc.) when their endpoints, enabled status, or certificate material changes. The configuration loading process has been refactored to use \serde\_ignored\, which now warns users about unknown or misplaced config keys instead of silently dropping them, and includes automatic migration for deprecated sections like \web\_admin\ and legacy \ssh.keepalive\_interval\ duration formats. Additionally, the CLI has been updated to support environment-variable-based config paths, a \--debug\ flag for granular log verbosity, and a \--log-format\ option to switch between text and JSON output.

warpgate/src · high confidence

The web interface has been upgraded to Svelte 5, utilizing the new $state, $props, and $derived syntaxes across the codebase. This location introduces a suite of shared UI components to support the new framework and enhance the user experience, including AsyncButton for visual feedback during asynchronous actions, AuthBar for logout and single-logout options, BannerModal for dismissible announcements, and CollapsibleBlock for sectioned forms. Additional components like ItemList (with pagination and grouping), ConnectionInstructions (supporting multiple protocols), and GettingStarted guide users through initial setup.

warpgate-web/src/common · high confidence

The web application has migrated its build system from the previous setup to Vite, introducing a new \vite.config.ts\ that defines entry points for the admin, gateway, and embed interfaces. This change accompanies an upgrade to Svelte 5, reflected in the updated \svelte.config.js\ which disables preprocess-level sourcemap emission to fix line drift issues. The project also adopts Biome for linting and formatting via a new \biome.json\, updates the TypeScript configuration with stricter checks like \verbatimModuleSyntax\, and upgrades the OpenAPI generator CLI version.

warpgate-web · high confidence

The warpgate-tls crate now includes a new cert module that parses certificate bundles to extract SNI names and expiry dates, and validates that private keys match their certificates. It also introduces a MaybeTlsStream and PrefixedStream mechanism that allows protocols like MySQL or PostgreSQL to upgrade a raw connection to TLS mid-stream, correctly handling leftover handshake bytes to prevent race conditions during the TLS upgrade process.

warpgate-tls · high confidence

The RDP connection logic in the \ironrdp-async\ and \ironrdp-connector\ modules has been replaced with a new asynchronous implementation. This change introduces a state-machine-driven connector that handles the full RDP negotiation sequence, including MCS channel management, capability exchange, and connection finalization. A key addition is native support for CredSSP authentication, allowing the client to perform Network Level Authentication (NLA) using either NTLM or Kerberos (via a configurable KDC proxy), as well as smart card credentials. The new architecture also includes an async framing layer for safe, cancel-safe I/O operations, addressing previous issues with connection stability and CPU usage during the handshake process.

vendor/ironrdp-async, vendor/ironrdp-connector · high confidence

The approvals subsystem has been refactored into a new, centralized module (warpgate-core/src/approvals) that manages both Just-In-Time (JIT) admin approvals and web-based user approvals. This change introduces a unified database-backed persistence layer for approval requests and decisions, ensuring that approval states are consistent across cluster nodes. For users, this means that admin approval gates now properly support the 'remember decision' feature, resolving previous issues where approvals were not retained if the only credential was a web approval. Additionally, the system now provides clearer UI feedback, such as a 'waiting' state for RDP sessions during admin approval, and handles session timeouts and refusals more robustly through a new \GateOutcome\ and \PendingApproval\ guard mechanism.

warpgate-core/src/approvals · high confidence

This change introduces a suite of new helper modules in warpgate-common/src/helpers that improve connection reliability, security, and configuration flexibility. It adds concurrent\_acceptor.rs and proxy\_protocol.rs to offload PROXY protocol header parsing to separate tasks, preventing stalled peers from blocking the accept loop and ensuring the listener remains available even during incomplete handshakes. It introduces net.rs with port-knock detection (ignoring connections that send no data within 1 second) and health-check filtering (dropping HAProxy probes that close immediately after sending a PROXY header). Security is strengthened by adding password\_policy.rs for configurable password rules, otp.rs for TOTP support, and hash.rs with a new hash\_secret function for deterministic hashing of high-entropy secrets. Additionally, fs.rs is updated to only apply file permissions when necessary, avoiding unnecessary permission changes.

warpgate-common/src/helpers · high confidence

The web interface now supports a new theming system with distinct dark and light modes, automatically switching based on the user's system preference or a saved user choice. This change introduces the 'Work Sans' font for the main UI and 'Poppins' for headings, along with a monospace fallback font for terminal-like elements. The theme is persisted in localStorage under the namespaced key 'warpgateTheme' to prevent collisions with proxied applications. Additionally, the theme layer suppresses Bootstrap's default 'valid' form validation styling, ensuring only invalid (red) feedback is shown, and applies font smoothing to the app container.

warpgate-web/src/theme · high confidence

The admin interface for user configuration has been rebuilt with new Svelte components that allow administrators to manage user credentials and access policies more granularly. Administrators can now define specific allowed IP ranges using CIDR notation via the new AllowedIpRangesEditor, restricting user access to designated networks. The updated CredentialEditor and AuthPolicyEditor components provide a unified view for managing passwords, SSH keys, certificates, OTP, and SSO credentials, while enforcing MFA policies and protocol-specific requirements (such as mandatory passwords for RDP/VNC). The main User.svelte page integrates these tools, allowing admins to edit credential policies, manage role assignments with expiry presets, and handle user deletion, all within a sectioned form layout.

warpgate-web/src/admin/config/users · high confidence

The RDP client implementation has been replaced with a new architecture based on the IronRDP library. This change introduces native keyboard layout support by prioritizing physical scancodes over keysyms, ensuring correct character input for non-US layouts. It also enables clipboard redirection between the viewer and the target, allows the RDP session to accept resolution changes from the client, and supports dynamic resizing. Additionally, the client now includes an interactive logon watcher that prevents keystroke recording during credential entry and excludes auto-reconnect secrets from logs. TLS connectivity is now configurable, supporting both Rustls and an optional OpenSSL backend for legacy cipher suites.

warpgate-protocol-rdp/src/client · high confidence

The admin interface for managing targets has been restructured into a new multi-page flow. Administrators now use a dedicated 'Choose Target Kind' page to select from SSH, HTTP, MySQL, PostgreSQL, Kubernetes, VNC, and RDP, followed by a simplified 'Create Target' form that handles basic naming and group assignment. The main 'Targets' list view now supports natural sorting, collapsible target groups, and filtering by group. Each individual target view includes a new 'Protocol Docs' section that displays protocol-specific requirements and supported features (such as TLS modes, authentication methods, and protocol versions) directly in the UI, and HTTP targets now feature a dedicated editor for custom request headers.

warpgate-web/src/admin/config/targets · high confidence

The SSH server's channel management has been restructured to improve reliability and prevent session hangs. A new \ChannelRegistry\ centralizes channel state, ensuring that events are correctly deferred during the channel open confirmation process to fix race conditions (e.g., \#2328). A dedicated \ChannelWriter\ with an outbound data budget (semaphore-based) prevents the session event loop from deadlocking when the client's receive window is full (e.g., \#2494). Additionally, an \EventIntake\ component ensures that control events continue to be processed even when the outbound data budget is exhausted, allowing the system to handle client window adjustments and keep the session alive.

warpgate-protocol-ssh/src/server · high confidence

The authentication logic in warpgate-common has been restructured into a modular system (cred, policy, state, selector) to support more granular control over login flows. This change introduces an MFA enforcement policy that allows administrators to require specific additional factors (such as TOTP) on top of existing credentials for specific protocols. It also implements a robust mechanism for remembering user approval decisions, allowing users to cache web-based approvals for single targets or all targets based on their submitted credential set, and adds support for new credential types including SSO and in-browser web approvals.

warpgate-common/src/auth · high confidence

The \warpgate-common\ types module has been reorganized from a single file into a structured module (\warpgate-common/src/types/\) containing distinct components. This change introduces a \ListenEndpoint\ type that ensures Warpgate correctly binds to both IPv4 and IPv6 addresses when the unspecified IPv6 address (\\[::\]\) is configured, and handles transient connection accept errors gracefully without killing the listener. It also adds a \Protocol\ enum to strictly identify supported protocols (HTTP, SSH, MySQL, etc.) and newtype wrappers for \UserSessionId\, \TargetSessionId\, and \NodeId\. Security and storage capabilities are enhanced with \StoredSecret\ for handling encrypted credentials and \SshHostKey\ for generating and managing SSH host keys, alongside a refactored \Secret\ type that now supports random generation and OpenAPI schema integration.

warpgate-common/src/types · high confidence

The database connection module and UUID serialization helpers in warpgate-common have been removed. This eliminates the previous implementation that handled SQLite path resolution, connection pooling, migration execution, and data sanitization/cleanup, as well as the Diesel-based binary serialization traits for UUIDs. These changes reflect a shift away from the prior database abstraction layer, likely in preparation for or following the sea-orm upgrade mentioned in the commit history.

warpgate-common/src/db · medium confidence

The \warpgate-common/src/protocols\ module has been removed, eliminating the legacy \ProtocolServer\ trait and the \WarpgateServerHandle\ struct. This change removes the previous mechanism for managing session state (such as setting usernames and target snapshots) and the generic interface for running protocol servers and testing targets, indicating a shift in how protocol implementations and session management are structured within the application.

warpgate-common/src/protocols · high confidence

The project now supports reproducible builds by remapping source paths (home and working directory) and enables Cargo linting with warnings for implicit features. The previous build configuration file has been replaced by a new TOML-based config that also activates the profile-hint-mostly-unused feature.

.cargo · high confidence

The configuration module has been refactored to introduce a new \defaults.rs\ module that centralizes default values for listen endpoints (HTTP, SSH, MySQL, PostgreSQL, Kubernetes, VNC, RDP), session/cookie ages, and protocol-specific timeouts (e.g., SSH inactivity, PostgreSQL idle timeout). The \target.rs\ module now defines distinct configuration structs for each protocol (SSH, HTTP, MySQL, PostgreSQL, Kubernetes, VNC, RDP), including specific authentication options like IAM role support for SSH and database targets, and TLS verification settings. A new \specific\_target.rs\ module provides a type-safe way to narrow down generic targets to their specific protocol options. Additionally, a \warnings.rs\ module has been added to track and display configuration and runtime warnings in the admin UI.

warpgate-common/src/config · high confidence

The SSH client implementation has been refactored to use the russh library's async channel API, replacing synchronous send operations with async awaits and introducing a dedicated SshClientError type for better error handling. This change also adds support for SSH jump hosts, allowing connections to traverse a chain of intermediate SSH targets, and introduces agent forwarding capabilities within the session channel.

warpgate-protocol-ssh/src/client · high confidence

Warpgate now detects and logs shell commands executed during web-SSH sessions by using a headless terminal emulator to parse the output stream, providing visibility into user activity. Additionally, SSH host and client keys are migrated from local files to the database for centralized management, and the protocol server interface is updated to use the new bind method.

warpgate-protocol-ssh/src · high confidence

The vendored \ironrdp-connector\ and \ironrdp-async\ crates have been updated to version 0.10.0. This update introduces a credential-less CredSSP mode, allowing RDP interactive logon where the server presents its own sign-in screen instead of auto-logging in with delegated credentials. It also fixes a CPU spin issue during RDP sessions by rejecting zero-length unmatched frames that previously caused infinite loops, and improves connection stability by correctly responding to connect-time bandwidth measure stops and handling server session-end error info PDUs.

vendor · high confidence

The web frontend assets (located in warpgate-web/dist) are now embedded directly into the application binary using RustEmbed, replacing the previous external serving mechanism. A new lib.rs module provides a lookup function to resolve built file paths from the Vite manifest, ensuring the application can correctly serve its static resources internally. This change also includes a minor TypeScript definition update for global fetch types.

warpgate-web/src · high confidence

The vendor/ironrdp-session crate has been replaced with a new implementation that handles the RDP active stage, fast-path graphics updates, and image decoding. This update introduces server-side pointer rendering, fixes bitmap shearing by repacking padded bitmap data, and adds support for RFX codec decoding and color palette updates, resulting in more accurate remote desktop visuals and input handling.

vendor/ironrdp-session · high confidence

Added test fixtures for SSH key authentication; Added test infrastructure for database and remote desktop services; New end-to-end test suite for admin approvals, cluster failover, and protocol gates.

The vendored IronRDP crates (ironrdp-async, ironrdp-connector, ironrdp-server) have been updated to version 0.10.0/0.13.0 with Rust edition 2024 and MSRV 1.89, including refreshed Cargo.lock files and dependency specifications. Additionally, the test suite's Python environment was restructured with new pyproject.toml and poetry.lock files, and the root package.json now includes the concurrently dev dependency.

(dependencies) · high confidence

The vendored \picky\ library has been updated to include new modules for HTTP message signing (\http\_signature\, \http\_request\) and a comprehensive JSON Object Signing and Encryption (JOSE) suite (\jose\ containing JWE, JWK, JWS, and JWT implementations). This update also introduces a new \hash\ module supporting algorithms like MD5, SHA-1, SHA-2, and SHA-3, and expands key support in \key/ec.rs\ and \key/ed.rs\ to handle EC (P-256, P-384, P-521) and Edwards curve (Ed25519, X25519) operations. These changes provide the underlying cryptographic primitives and serialization logic required for the RDP client resolution request handling.

vendor/picky, vendor/sspi · high confidence

This change introduces several configuration and maintenance updates: a new \.all-contributorsrc\ file to track contributors, a \SECURITY.md\ defining the vulnerability reporting scope, and a \bumpver.toml\ for version management. The \justfile\ is updated to use \npm\ instead of \yarn\ for frontend tasks and adds new commands for linting and database migrations. The \deny.toml\ configuration is refreshed with new dependency advisories to ignore, and the \rust-toolchain.toml\ is updated to a newer nightly channel. Additionally, the \README.md\ is significantly expanded with badges, documentation links, and a comparison table, while the \LICENSE\ file is updated with the current copyright year.

(repo-wide) · high confidence

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

• CAI 58 → 60 (+2.7)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 49 → 49 (-0.0)
• Architecture 67 → 69 (+2.2)
• Maturity 61 → 65 (+3.9)
• Readiness 62 → 79 (+17.2)
• Security 64 → 68 (+3.6)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)

• Boundary-crossing change coupling: Parameters.rs ↔ lib.rs (warpgate-db-entities/src/Parameters.rs)
• Change coupling: lib.rs ↔ Parameters.svelte (warpgate-db-migrations/src/lib.rs)
• ClassTooLong: RemoteClient (warpgate-protocol-ssh/src/client/mod.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (13 lines × 2) (warpgate-protocol-mysql/src/client.rs)
• Duplicated block (14 lines × 4) (warpgate-common/src/audit.rs)
• High IaC: KSV-0014 (helm/warpgate/templates/setup-job.yaml)
• Hotspot: vendor/ironrdp-session/src/fast_path.rs (vendor/ironrdp-session/src/fast_path.rs)
• Hotspot: vendor/vnc-rs/src/codec/trle.rs (vendor/vnc-rs/src/codec/trle.rs)
• Hotspot: vendor/vnc-rs/src/codec/zrle.rs (vendor/vnc-rs/src/codec/zrle.rs)
• Hotspot: warpgate-common/src/config/mod.rs (warpgate-common/src/config/mod.rs)
• Hotspot: warpgate-desktop-auth/src/hold_screen.rs (warpgate-desktop-auth/src/hold_screen.rs)
• Hotspot: warpgate-protocol-rdp/src/client/input.rs (warpgate-protocol-rdp/src/client/input.rs)
• Hotspot: warpgate-protocol-rdp/src/server/rdp.rs (warpgate-protocol-rdp/src/server/rdp.rs)
• Hotspot: warpgate-protocol-ssh/src/client/channel_session.rs (warpgate-protocol-ssh/src/client/channel_session.rs)
• Hotspot: warpgate-protocol-ssh/src/server/target_menu.rs (warpgate-protocol-ssh/src/server/target_menu.rs)
• Hotspot: warpgate-protocol-vnc/src/server/protocol.rs (warpgate-protocol-vnc/src/server/protocol.rs)
• Hotspot: warpgate-web/src/admin/log-viewer/LogViewer.svelte (warpgate-web/src/admin/log-viewer/LogViewer.svelte)
• …and 23 more

• ClassTooLong: AuditEvent (warpgate-common/src/audit.rs)
• Connector::_handle_auth_result (cognitive 19) (warpgate-protocol-ssh/src/client/mod.rs)
• Connector::authenticate_session (cognitive 24) (warpgate-protocol-ssh/src/client/mod.rs)
• Duplicated block (13 lines × 2) (warpgate-protocol-mysql/src/client.rs)
• Duplicated block (14 lines × 2) (warpgate-common/src/audit.rs)
• Duplicated block (8 lines × 6) (warpgate-common/src/audit.rs)
• Duplicated block (9 lines × 2) (warpgate-common/src/audit.rs)
• Duplicated block (9 lines × 2) (warpgate-common/src/audit.rs)
• End-of-life runtime: .NET net6.0
• FileTooLong: src/audit.rs (warpgate-common/src/audit.rs)
• FunctionTooLong: warpgate_protocol_http::proxy::proxy_ws_inner (warpgate-protocol-http/src/proxy.rs)
• FunctionTooLong: warpgate_protocol_kubernetes::server::handlers::_handle_websocket_request_inner (warpgate-protocol-kubernetes/src/server/handlers.rs)
• Hotspot: warpgate-common/src/error.rs (warpgate-common/src/error.rs)
• Hotspot: warpgate-core/src/credential_encryption.rs (warpgate-core/src/credential_encryption.rs)
• Inconsistent abbreviation for 'User'. The type and property are named 'Usr', while other credentials use 'User' (e.g., 'AADJoin.Creds.UserCreds', 'AADJoin.Messages.JoinDeviceRequest.User' is not present but 'UserCreds' is). 'Usr' is a non-standard abbreviation.
• Inconsistent abbreviation for the same concept. 'MembershipChgs' is used as a nested type name for specific SIDs, while 'MembershipChanges' is used as the property name for the collection. 'Chgs' is a non-standard abbreviation for 'Changes'.
• Inconsistent casing for factory/parse methods. 'AuthResponse.fromString' uses lowercase 'f', while 'JoinDeviceResponse.FromString', 'TenantAuthResponse.FromString', and 'P2PCertificatesResponse.FromString' use PascalCase 'F'.
• Inconsistent constructor patterns for wrapping streams. StreamWrapper uses a static factory method from_inner, while Framed uses new and new_with_leftover. This forces users to remember different instantiation patterns for similar wrapper types.
• Inconsistent naming for standard I/O operations. FramedRead uses read (standard Rust Read trait name), while FramedWrite uses write_all (standard Rust Write trait method for full buffer writes). This creates asymmetry in the API surface.
• Inconsistent return types for get_inner/get_inner_mut. StreamWrapper returns the inner stream directly, while Framed returns a tuple of references. This inconsistency requires different handling code depending on which wrapper type is being used.
• …and 22 more

• 47 commits — 37 feature/other, 10 fixes

• (root) — 8 commits
• warpgate-web/src — 7 commits
• warpgate-admin/src — 5 commits
• (repo) — 4 commits
• warpgate-protocol-kubernetes/src — 3 commits
• warpgate-protocol-ssh/src — 3 commits
• tests/conftest.py — 2 commits
• warpgate-common-http/src — 2 commits
• .github/workflows — 1 commit
• helm/warpgate — 1 commit
• tests/test_cluster_failover.py — 1 commit
• tests/test_util_wait_port.py — 1 commit
• vendor/ironrdp-connector — 1 commit
• vendor/ironrdp-server — 1 commit
• warpgate-common/src — 1 commit
• warpgate-core/src — 1 commit
• warpgate-db-entities/src — 1 commit
• warpgate-db-migrations/src — 1 commit
• warpgate-desktop-auth/src — 1 commit
• warpgate-protocol-http/src — 1 commit

• fix: SSH - #2598 recording gap fix
• fix: fix(deps): bump cryptoki to 0.12.1 to resolve RUSTSEC-2026-0286 (#2604)
• fix: fixed #2585 - RDP CPU spin (#2591)
• fix: fixed #2590 - run migrations in a transaction (#2595)
• fix: fixed #2594 - generate TOTP with a CSPRNG
• fix: fixed #2597 - reject changing PK/SSO credential ownership
• fix: fixed #2605 - displaying expired role memberships for user
• fix: fixed #2613 - cannot remember approval if the only cred is web approval
• fix: fixed #2614 - show "waiting" UI on RDP while waiting for admin approval (#2615)
• fix: vendor ironrdp-server and and patch to potentially fix #2606
• change: Add scope clarifications to SECURITY.md (#2509)
• change: Audit Kubernetes exec, attach, port-forward and debug containers (#2558)
• change: Bump the actions-updates group across 1 directory with 9 updates (#2610)
• change: Cluster notifications (#2587)
• change: Detangle SSH session <> RC wait (#2603)
• change: Forward test_direct_tcpip to a local server instead of github.com (#2625)
• change: HashiCorp Vault / OpenBao integration for secret management (#2185)
• change: Helm chart updates
• change: Implement Kubernetes access tickets (#2562)
• change: Let go of a client that stopped reading when its target dies (#2520) (#2549)
• …and 27 more

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

warp-tech/warpgate 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.