Skip to content
CAI
Software that uses CAICheck a score

CanineHQ/canine

39.8

Weak · 6 November 2026

30.6k

lines of production code

Ruby

with JavaScript, Python

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Bitbucket support to the Git client service

The \app/services/git\ layer now supports Bitbucket repositories in addition to GitHub and GitLab. A new \Git::Bitbucket::Client\ implementation handles Bitbucket's API v2 for fetching commits, pull requests, and files, as well as managing webhooks. The central \Git::Client\ factory has been updated to instantiate this new client when a project's provider is identified as Bitbucket, allowing users to connect and deploy from Bitbucket-hosted codebases.

app/services/git · high confidence

Add OpenRouter client and local Langfuse tracing infrastructure

Developers can now integrate with the OpenRouter API via a new \Llm::OpenRouter\ service that handles chat completions, token usage, and cost reporting. Additionally, a local Langfuse environment is provided in \dev/langfuse\ (using Docker Compose and SeaweedFS for storage) to enable optional, non-blocking tracing of agent sessions, including full request/response logs and screenshots.

app/services/llm, dev · high confidence

Add Sentry-compatible error ingestion and grouping

The application now accepts error reports in the Sentry envelope format, handling gzip/deflate decompression and validating item counts and payload lengths to prevent resource exhaustion. Incoming events are grouped into issues using a fingerprint derived from exception types and normalized in-app stack frames, which ensures consistent grouping across different builds and deployments. Each event is stored with metadata such as release, environment, and timestamp, and existing issues are updated or reopened automatically when similar errors recur.

_app/services/error\tracking · high confidence

Add TOTP two-factor authentication with recovery codes

Users can now enable Time-based One-Time Password (TOTP) two-factor authentication. The setup flow displays a QR code and secret key for authenticator apps, followed by a screen to save and copy/print/download a set of one-time recovery codes. During login, users can verify their identity using either an authenticator app code or a recovery code, with a toggle to switch between the two methods.

_app/views/two\_factor\_authentication, app/views/two\_factor\verifications · high confidence

Add ability to favorite projects, clusters, and add-ons

Users can now mark projects, clusters, and add-ons as favorites. This change introduces a toggle action to add or remove favorites, a query action to retrieve a user's favorited items, and a UI button component that allows toggling the favorite status via Turbo Stream. A development seed task is also added to generate fake data for testing this feature.

app/actions/favorites, app/views/favorites, lib/tasks/development · high confidence

Add agent computer resources: bigarrow overlay and computer-use server

This change introduces two new resource packages for agent computers. The \bigarrow\ package provides a Wayland overlay tool that displays large, clickable arrows, rings, or boxes on the screen to guide users to specific windows or areas, and includes an annotation module to mark up screenshots for run logs. The \computer-use\ package adds an HTTP server that allows AI agents to interact with the Linux desktop via Anthropic's computer-use tool actions, leveraging the AT-SPI accessibility tree to find and click UI elements by name rather than guessing coordinates, along with workspace isolation to keep agent activity separate from the user's session.

resources · high confidence

Add build cloud management UI

Users can now install, configure, and manage build clouds directly from the cluster settings page. This includes a new section that displays the build cloud status (active, installing, failed, etc.), allows editing of resource configurations such as replicas, CPU, and memory limits, and provides options to install, reinstall, or remove the build cloud environment.

_app/views/clusters/build\clouds · high confidence

Add internal auth proxy and configurable ingress for add-ons

Add-ons now support an internal authentication proxy and configurable Kubernetes ingress. The new AuthProxy service manages OIDC issuer URLs (derived from the app host), client credentials, and cookie secrets for secure access. Additionally, the Ingress service automatically selects the appropriate ingress class (Traefik or Nginx) based on the cluster's installed packages, allowing add-ons to be exposed via the correct routing layer.

_app/services/k8/add\ons · high confidence

Add project notifier management UI

Users can now configure and manage notification integrations for their projects via a new web interface. The system supports Slack, Discord, Microsoft Teams, Google Chat, and Email providers, allowing users to specify webhook URLs, select which event types to monitor (builds, deployments, and health alerts), and enable or disable notifications. The UI includes a list view of existing notifiers with options to edit, delete, or send test notifications, along with a form for creating new configurations.

app/views/projects/notifiers · high confidence

Add repository selection modal and list view for integrations

Users can now select repositories for integration via a new modal interface. This includes a searchable list of available repositories with a 'Connect' action for each, and a dedicated section allowing users to manually specify a public repository URL by entering the 'username/repo' format.

app/views/integrations · high confidence

Add search, sorting, and bulk update capabilities to error issues

Users can now search error issues by title, culprit, or short ID, and perform bulk actions (resolved, unresolved, ignored, or delete) on selected issues. This change introduces dedicated action classes for search and bulk updates, enabling more efficient management of error issues within the application.

_app/actions/error\issues · high confidence

Add version selector view model for add-ons

Introduced a new view model (Async::AddOns::VersionSelectorViewModel) that handles the asynchronous loading of Helm chart versions for a specific add-on. It fetches chart details from the add-on's repository URL and renders either a version selection list or an error message if the chart is not found or the fetch fails.

_app/view\_models/async/add\ons · high confidence

Add webhook notification support for Slack, Discord, Microsoft Teams, and Google Chat

Users can now receive notifications via webhooks to Slack, Discord, Microsoft Teams, and Google Chat. This change introduces a new \ProjectWebhook\ bulk delivery method that iterates over enabled project notifiers (excluding email) and sends formatted payloads using the \WebhookBuilder\. The builder constructs platform-specific message structures, including status indicators, descriptions, widgets, and action buttons, allowing these external services to display rich, interactive notification cards.

app/notifiers · high confidence

Add-on lifecycle and cleanup jobs

Introduced dedicated background jobs to manage the full lifecycle of add-ons: installation (with optional restart), uninstallation, and demo-mode reset. A new cleanup job automatically removes auth-proxy Kubernetes resources (deployments and services) associated with an add-on, ensuring stale proxy components are removed when no longer needed.

_app/jobs/add\ons · high confidence

Add-on process pods view with loading skeleton

The pods view for add-on processes now uses a dedicated view model that fetches pod data via a Kubernetes connection based on the add-on's cluster, and displays a skeleton loading state while data is being retrieved.

_app/view\_models/async/add\ons/processes · high confidence

Added ACME issuer service for certificate management

A new K8::Shared::AcmeIssuer service has been introduced to handle ACME issuer configuration. This service accepts an email address, an ingress class name, and an optional namespace (defaulting to Clusters::Install::DEFAULT\_NAMESPACE), enabling the system to manage certificate issuance for the specified Kubernetes ingress resources.

app/services/k8/shared · high confidence

Added Active Admin asset pipeline configuration

The application now includes the necessary JavaScript and Sass files to integrate Active Admin into the asset pipeline. A new JavaScript manifest requires the Active Admin base script, and a new Sass stylesheet imports Active Admin's mixins and base styles, allowing for standard customization of the admin interface's appearance.

vendor · high confidence

Added GitHub webhook status view model

A new view model has been introduced to display the connection status of a GitHub webhook for a specific project. Users will now see a real-time indicator showing whether a webhook is successfully connected (marked with a green check) or not found (marked with a red cross), with a loading spinner displayed during the asynchronous check.

_app/view\models/async/github · high confidence

Added HTML email template for notifications

A new HTML email template has been added for the notifier mailer, providing a styled layout for notification messages. The template displays a title, a list of key-value fields (with labels and code-styled values), and a call-to-action button linking to a specified URL, ensuring consistent visual presentation for user notifications.

_app/views/notifier\mailer · high confidence

Added LDAP authentication strategy for Devise

Users can now authenticate against LDAP servers via a new Devise strategy. This change introduces the \LDAPAuthenticatable\ strategy class, which validates credentials against an LDAP server and, if configured, automatically provisions user teams via Just-In-Time provisioning. The strategy is scoped to accounts with SSO enabled and specifically configured for LDAP, ensuring that only eligible accounts can utilize this authentication method.

lib/devise · high confidence

Added Madmin admin dashboard routes

A new Madmin admin dashboard is now available, providing administrative access to manage core platform resources. Users with appropriate permissions can now view and edit records for projects, users, deployments, builds, clusters, domains, services, add-ons, and environment variables. The dashboard also includes management capabilities for system components such as cron schedules, inbound webhooks, log outputs, metrics, and announcements, as well as Active Storage assets (blobs, attachments, variant records) and notification events.

config/routes · high confidence

Added Rancher integration for cluster management

This change introduces a new integration with Rancher, allowing users to connect their Rancher stack manager to synchronize and manage Kubernetes clusters. The implementation includes a client library for interacting with the Rancher API (handling authentication, cluster listing, and kubeconfig generation), data models for users and clusters, and an onboarding workflow that validates the environment, creates the necessary user and account records, and triggers the initial cluster sync. Users can now leverage Rancher as a provider for their cluster infrastructure within the platform.

lib/rancher · high confidence

Added RegistrySecret service for Kubernetes secret generation

A new service class, K8::Secrets::RegistrySecret, has been introduced to handle the creation of Kubernetes secrets for container registry credentials. This component accepts a project identifier and a Docker configuration JSON object, providing a dedicated interface for managing registry-specific secret data within the application.

app/services/k8/secrets · high confidence

Added SAML authentication service

Introduced a new SAML authenticator service that handles user authentication via SAML responses. The service validates incoming SAML assertions, extracts user attributes such as email, name, and UID, and manages authorization URLs and metadata generation using the OneLogin RubySAML library.

app/services/saml · high confidence

Added background jobs for cluster lifecycle and package management

This change introduces a set of new background jobs in the \app/jobs/clusters\ directory to handle cluster and package operations asynchronously. Specifically, it adds \InstallJob\ and \DestroyJob\ for basic cluster installation and deletion, as well as \InstallBuildCloudJob\ and \DestroyBuildCloudJob\ to manage the installation and removal of the build cloud environment on a cluster. Additionally, it includes \InstallPackageJob\, \UninstallPackageJob\, and \SyncPackagesJob\ to handle the installation, uninstallation, and synchronization of packages on clusters, including logic to skip installation if a package is already present. These jobs delegate to existing service objects (e.g., \Clusters::Install\, \Clusters::SyncPackages\) and utilize Kubernetes clients (\K8::Connection\, \K8::Kubectl\) to perform the actual operations.

app/jobs/clusters · high confidence

Added bin scripts for local development and Docker execution

The repository now includes a set of executable scripts in the \bin/\ directory to streamline the development and deployment workflow. \bin/dev\ and \bin/run\ utilize Foreman to start the application and associated processes, with \bin/dev\ specifically enabling remote debugging and defaulting to port 3000. \bin/docker-entrypoint\ configures the runtime environment by enabling jemalloc and YJIT for performance, and automatically prepares the database when starting the Rails server or development tools. Additionally, \bin/setup\ automates the initial environment configuration by installing dependencies, preparing the database, and clearing logs.

bin · high confidence

Added build pack search input component

A new partial view for build packs has been introduced, providing a user-facing search input field. This component allows users to filter build packs by name (e.g., ruby, node, python) and is wired to a JavaScript controller named 'buildpack-search' to handle the search logic.

_app/views/build\packs · high confidence

Added cluster setup instructions for K3s, managed Kubernetes, and local K3s

The cluster creation flow now includes specific instruction views for three cluster types. For K3s, users are guided through entering a server IP, running an installation command (with UFW configuration hints), and pasting the resulting kubeconfig. For managed Kubernetes providers (DigitalOcean, Linode, or Other), users select their provider and upload a kubeconfig file. For local K3s, users select their operating system (macOS, Linux, or Windows) and paste the kubeconfig output.

_app/views/clusters/cluster\types/instructions · high confidence

Added email templates for account invitations and additions

Users now receive formatted HTML and plain-text emails when they are invited to join an account or added to an existing one. The invitation email provides the user's email address, a temporary password, and a login link, while the addition email simply confirms access to the new account with a login link.

_app/views/account\_invite\mailer · high confidence

Added global search action to aggregate projects, clusters, and add-ons

A new \GlobalSearch::Search\ action has been introduced to handle global search queries. When a user provides a search term, this action concurrently retrieves matching projects, clusters, and add-ons by delegating to their respective list services, applying the specified limit to each result set. If the query is empty, it returns empty arrays for all categories.

_app/actions/global\search · high confidence

Added mobile terminal demo and pricing data resources

The public resources directory now includes a mobile-optimized terminal recording (\demo-mobile.cast\) alongside the existing desktop demo, providing a specific view for mobile users. Additionally, a new \prices.json\ file has been added to supply structured pricing data for Heroku, DigitalOcean, Hetzner, and Render, enabling the frontend to display accurate cost comparisons for these cloud providers.

public/resources · high confidence

Added resource constraint creation and update actions

Users can now create and update resource constraints for namespaces. The new \ResourceConstraints::Create\ and \ResourceConstraints::Update\ actions handle the workflow, while the underlying \ResourceConstraints::Save\ action processes the input by converting blank strings to nils and transforming CPU values from cores to millicores before persisting the changes.

_app/actions/resource\constraints · high confidence

Added shared error message partial

A new shared partial, \_error\_messages.html.erb, has been added to the application views. This component provides a consistent, styled alert for displaying validation errors on resources, utilizing Bootstrap classes and internationalized messages.

app/views/application · high confidence

Added skeleton loading components for fields and tables

Introduced two new shared view components, \\_field\_skeleton.html.erb\ and \\_table\_skeleton.html.erb\, to provide visual placeholders during data loading. The field skeleton supports small, medium, and large sizes, while the table skeleton renders rows with either two or more columns, using CSS classes to display animated loading states.

app/views/shared/components · high confidence

Added storage volume usage view

A new partial view for displaying storage metrics has been added, allowing users to see volume names, usage percentages, and available space with progress bars. If no storage volumes are detected, a 'No storage volumes found' message is displayed.

app/views/helm · high confidence

Added test notification action

A new \Notifiers::SendTest\ action has been introduced to handle the sending of test notifications. This action supports both email and webhook providers: for email, it verifies SMTP configuration via \SmtpUtilities\ before sending a test email through \NotifierMailer\; for webhooks, it constructs a payload and posts it to the notifier's webhook URL. Errors during transmission are caught and returned as failure reasons.

app/actions/notifiers · high confidence

Added volume management UI for projects

Users can now create, view, and delete volumes within a project. The new interface includes a form to specify volume name, size, and mount path, a list view displaying volume details and status badges (pending, deployed, failed), and a delete action with confirmation.

app/views/projects/volumes · high confidence

Added welcome email templates for new sign-ups

New HTML and text email templates have been added for the sign-up mailer. Users will now receive a welcome message upon registration that addresses them by name or email and confirms they are set up to start deploying applications.

_app/views/sign\_up\mailer · high confidence

Agent computer lifecycle management via dedicated background jobs

Users can now have their agent computers started, stopped, and destroyed through dedicated background jobs (ProvisionJob, StartJob, StopJob, DestroyJob) that manage the underlying KubeVirt VMs. Provisioning handles the full lifecycle of importing the Omarchy ISO, installing the OS, and configuring the desktop stream and computer-use server, while Start and Stop jobs allow pausing and resuming the VM to conserve resources without losing data. A RefreshTurnJob ensures video streaming credentials remain valid, and all operations are isolated in their own queue to prevent blocking other system tasks.

_app/jobs/agent\computers · high confidence

Async cluster metrics view model

Added a new view model for asynchronously loading and displaying cluster metrics. This component fetches node metrics via the K8::Metrics::Api and renders them in a live metrics table, providing a skeleton UI during the initial render phase.

_app/view\models/async/clusters · high confidence

Async rendering for project metrics and processes with loading skeletons

The project metrics and processes pages now use asynchronous view models to fetch and display data, improving perceived performance by showing a table skeleton during loading. For metrics, the view model fetches project details and renders live metrics, while for processes, it retrieves pods from the project's namespace using the Kubernetes client and displays them in a table, handling empty states appropriately.

_app/view\models/async/projects · high confidence

Automated TODO tracking via pre-commit hook

A new pre-commit hook has been added to automatically capture TODO comments from staged Ruby (.rb) and ERB (.erb) files. When a commit includes changes with TODOs, the hook appends these items to a dedicated TODO.md file and stages that file for inclusion in the commit, ensuring that pending tasks are consistently recorded without manual intervention.

.githooks · high confidence

Automatic DNS record creation for managed domains

Users with domains marked as auto-managed can now have DNS records (A or CNAME) created automatically when services are deployed. This feature introduces a new \Dns::AutoSetupService\ that validates the domain against the configured Cloudflare zone, infers the correct hostname from the Kubernetes ingress, and provisions the necessary DNS record via the Cloudflare API. The system supports both IP-based (A) and hostname-based (CNAME) records, handling updates if the record already exists, and requires the \ENABLE\_AUTOMATIC\_DNS\_MAPPING\ environment variable along with valid Cloudflare credentials to activate.

app/services/dns · high confidence

Cluster package management UI for installation and configuration

The cluster packages view now provides a user interface for selecting, installing, and managing system packages on a cluster. Users can view package status (installed, installing, failed, etc.), install optional or recommended packages, and configure template variables (such as AWS credentials or S3 bucket names) via pattern-validated form fields. The interface supports enabling/disabling packages, uninstalling, and retrying failed installations.

_app/views/clusters/cluster\packages · high confidence

Custom domain management interface for services

Users can now add, view, and remove custom domains for their services directly from the project interface. The new view includes a form to register domain names, a table listing existing domains with their associated ingress controller (Traefik or Nginx), and asynchronous rendering for cluster IP and certificate status. Domain names are clickable to copy to the clipboard, and a dedicated button allows users to manually refresh DNS verification status, with visual feedback provided via status badges and confirmation messages.

app/views/projects/services/domains · high confidence

Helm add-on now supports Artifact Hub, custom repositories, and OCI registries

The Helm add-on configuration form has been updated to offer three distinct sources for installing charts. Users can now search for charts directly via Artifact Hub, specify a custom Helm repository URL to browse and select charts, or install charts from an OCI-compatible container registry. This replaces the previous single-source approach with a radio-selector interface that dynamically loads the appropriate input fields for each source type.

_app/views/add\ons/helm · high confidence

Initial Portainer integration for cluster and registry synchronization

This change introduces the core library components for integrating with Portainer, enabling the system to authenticate via Portainer, retrieve access tokens, and synchronize Kubernetes clusters and container registries. Users will now have the underlying infrastructure in place for Portainer-based onboarding, allowing the platform to discover and install clusters managed by Portainer and sync associated container registry credentials.

lib/portainer · high confidence

Initial Stimulus controller suite for core UI features

This change introduces a comprehensive set of new Stimulus controllers to power the application's interactive frontend components. Key additions include a global search interface with keyboard navigation, a pricing calculator with dynamic charting, and buildpack management tools with drag-and-drop sorting. The update also brings in controllers for environment variable management (with reveal/hide and secret/config toggling), log streaming, cluster setup wizards (including K3s validation), and various form helpers like email validation and content toggling, establishing the foundational JavaScript behavior for the platform's UI.

app/javascript/controllers · high confidence

Initial configuration of core Rails application and admin panel

This change introduces the foundational configuration for the application's initializers, establishing the baseline behavior for the Rails 7.2 framework and its key integrations. It sets up the Avo admin panel with custom branding and authentication, configures Devise for user management, and implements OAuth/OIDC capabilities via Doorkeeper. Background job processing is defined through GoodJob with specific queues for builds and monitoring, while email delivery is wired to SMTP settings. Additional initializers handle security policies, feature flags via Flipper, pagination, error styling, and observability through Sentry.

config/initializers · high confidence

Initial database schema and foundational migrations

This change introduces the complete initial database schema for the application, establishing the core data models required for the platform. It creates tables for user authentication (users, providers), multi-tenancy (accounts, account\_users, teams, team\_memberships), and project management (projects, clusters, deployments, builds, services, add\_ons). It also adds infrastructure for CI/CD and container management (build\_configurations, build\_clouds, build\_packs, volumes, environment\_variables), observability (metrics, events, log\_outputs), and user experience features (favorites, announcements, notifications via Noticed). Additionally, it integrates third-party libraries by creating tables for Active Storage, FriendlyId, Active Admin (later dropped), Flipper feature flags, and Doorkeeper OAuth, while configuring background job processing with Good Jobs.

db/migrate · high confidence

Initial database schema and seed file added

The database schema is now defined in \db/schema.rb\ (version 2026\_09\_19\_152959) and includes tables for accounts, users, clusters, builds, add-ons, and API tokens, alongside a new \db/seeds.rb\ file to initialize required data. This establishes the foundational data structures for account management, cluster tracking, and build configurations.

db · high confidence

Initial release of Canine, a self-hosted Kubernetes deployment platform

The repository has been rebranded from 'Jumpstart' to 'Canine', shifting from a generic Rails application template to a specialized Platform-as-a-Service for Kubernetes. This change introduces a complete application architecture for managing Kubernetes clusters, including Docker image building, Git-driven deployments, and service management via a web interface. The backend now utilizes GoodJob for background processing instead of Sidekiq, and the frontend employs Hotwire (Turbo/Stimulus) with Tailwind CSS. The project provides production and development Docker configurations, supports multi-tenancy, and includes integrations for GitHub/GitLab webhooks, Docker registries, and DNS management.

(repo-wide) · high confidence

Initial release of the v1 REST API

This change introduces the complete v1 API controller layer, providing programmatic access to core platform resources. Users can now manage their infrastructure and deployments via HTTP requests, including listing and downloading kubeconfigs for clusters, viewing and killing in-progress builds, and performing project operations such as deploying the latest commit, restarting services, and running diagnostic checks. The API enforces authentication via the X-API-Key header and scopes all actions to the authenticated user's accessible accounts and projects.

app/controllers/api/v1 · high confidence

Introduce Agent Computers feature with gated access and task management

This change introduces the Agent Computers feature, making it available behind the \agent\_computers\ Flipper flag. It adds controllers for managing agent computers, including tasks (with scheduling and OpenRouter key requirements), sessions (with live updates and screenshot support), and a feed of agent activities. The feature is structured under the \agent\_computers\ namespace, with a base controller handling authentication and computer context.

_app/controllers/agent\computers · high confidence

Introduce Agent Computers with live desktop, task feed, and session tracking

Users can now provision and manage cloud Linux desktops for agents. The new Agent Computers section includes a list view, a first-run intro, and a settings page where you configure the OpenRouter models used for planning, browsing, and coding. You can start, stop, and destroy computers, and view their provisioning progress. Each computer has a Feed where you can compose tasks to run immediately or on a schedule, and watch live results with screenshots. You can also connect to the desktop via a fullscreen iframe that captures keyboard shortcuts, with support for taking control from another tab. Finally, individual session pages show a live timeline of actions, screenshots, and a final summary.

_app/views/agent\computers · high confidence

Introduce BigArrow visual targeting for Wayland agents

Added a new 'bigarrow' module that provides geometric layout and target detection capabilities for visual agents on Hyprland. The new geometry.py file defines logic for calculating optimal arrow placement (sign, shaft, and head) to point at screen targets while avoiding overlaps and staying within screen margins. The targets.py file integrates with Hyprland via hyprctl to detect monitors, cursor positions, and specific windows, enabling the agent to visually identify and highlight UI elements.

bigarrow-wayland · high confidence

Introduce Helm-based add-on management and service integration

This change introduces a new Helm-based infrastructure for managing add-ons, replacing previous deployment methods. It adds a \K8::Helm::Client\ to handle Helm CLI operations (install, upgrade, uninstall, value retrieval) and a \ChartBuilder\ for programmatic chart creation. Specific service integrations are added for Redis, PostgreSQL, and ClickHouse, enabling the system to automatically detect these add-ons, retrieve their connection details (such as passwords and internal URLs) from Kubernetes secrets, and expose storage metrics. This allows users to install and manage these data services as add-ons with standardized Helm deployments.

app/services/k8/helm · high confidence

Introduce Stack Manager configuration UI for Portainer integration

The Stack Manager settings page now provides a complete interface for configuring and managing Portainer connections. Users can create or edit configurations by selecting a manager type, entering the Portainer URL and access token, and optionally enabling Role Based Access Control (RBAC) to restrict cluster access to the user's session while using the token for async Git deployments. The interface includes real-time connection status indicators, a manual 'Test Connection' button to verify credentials, and a 'Sync Clusters' action to update the local cluster list. An empty state guides new users to set up their first manager, while existing configurations display provider details, RBAC status, and allow for editing or removal.

_app/views/accounts/stack\managers · high confidence

Introduce agent computer infrastructure and control services

This change adds the core service layer for the new 'agent computers' (previously 'agent sandboxes'), replacing the previous Ubuntu-based setup with KubeVirt VMs running the Omarchy desktop environment. It introduces several new components: \ComputerUse\ for driving the agent's desktop via a local HTTP server (supporting actions like clicking, screenshots, and terminal access); \GuestShell\ for executing commands inside the VM via SSH; \PortForward\ and \KubectlForward\ for managing secure tunnels to the VM's ports; \Omarchy\ for defining the VM's unattended installation and configuration; \Stats\ for monitoring VM health and resource usage; \Turn\ for managing WebRTC credentials for the desktop stream; and \Unschedulable\ to provide human-readable reasons when a VM cannot be placed on a cluster node.

_app/services/agent\computers · high confidence

Introduce agent computer proxy for secure VM desktop access

Added a new Rack middleware (lib/agent\_computer\_proxy.rb) that reverse-proxies HTTP and WebSocket requests to agent computer VMs via kubectl port-forward. This enables users to access the desktop interface of their agent computers securely through the application, handling authentication, tunnel management, and idle cleanup automatically.

lib · high confidence

Introduce agent computer session UI controllers

Added a suite of Stimulus controllers under the agent\_computers namespace to power the new agent computer session interface. These include desktop\_controller for managing the remote desktop iframe (health checks, fullscreen, and connection status), lightbox\_controller for browsing session screenshots, deep\_link\_controller for navigating to specific steps and actions, feed\_day\_controller for organizing the agent feed by date, compose\_controller for scheduling tasks, elapsed\_controller for displaying session duration, stalled\_controller for detecting unresponsive runs, and reveal\_controller for typing out agent notes.

_app/javascript/controllers/agent\computers · high confidence

Introduce autonomous agent loop with browsing, coding, and context management

Added a new agent loop service (app/services/agent\_loop) that enables AI agents to run unattended tasks on a user's computer. The system includes tools for web browsing (via a browser-use agent), coding (via a delegate agent), and shell execution, all coordinated by a central loop that manages turns, context, and tool calls. To handle long-running sessions, the loop implements context compression by folding older turns into session notes and shortening tool results to manage token usage. It also includes safeguards such as a loop guard to detect and stop repetitive model behavior, budget policies to enforce time and cost limits, and a post-generation module to create readable summaries of agent activities for the user's feed. The entire session is traced via Langfuse for observability.

_app/services/agent\loop · high confidence

Introduce background jobs for service health monitoring and Stripe billing sync

This change adds new background jobs to handle service health checks and billing synchronization. The \CheckServiceHealthJob\ runs in the \monitoring\ queue to verify Kubernetes deployment status, enforcing a 10-second timeout, and triggers email notifications when a service goes down or recovers. The \FetchClusterMetricsJob\ similarly operates in the \monitoring\ queue to collect cluster metrics with the same timeout constraint. Additionally, the \StripeSyncUsageJob\ ensures that Pro plan accounts have their Stripe subscription quantities updated to match the current number of billable clusters, running only when \cloud\_mode\ is enabled. These jobs rely on the newly created \ApplicationJob\ base class which configures retry behavior for standard errors.

app/jobs · high confidence

Introduce cloud-based Docker build execution with automatic build arguments

Users can now build Docker images using a remote 'Build Cloud' infrastructure instead of local execution. This change introduces a new \Builders::BuildCloud\ service that executes \docker buildx\ commands against a Kubernetes cluster, supporting multi-platform builds (linux/amd64, linux/arm64) and pushing directly to the registry. The system automatically injects \GIT\_SHA\ and \BUILD\_TIMESTAMP\ as build arguments into every build. Additionally, a new \Builders::Base\ class standardizes registry login and cleanup, while the \Workbench::Status\ service provides specific feedback for git clone failures during environment setup.

app/services/builders · high confidence

Introduce error tracking UI for viewing and managing project issues

Adds a new interface for project error tracking, including an index page with search, sorting, status filtering, and bulk actions (resolve, ignore, delete) for error issues. The issue detail view displays a 24-hour event trend graph, issue metadata, and action buttons, while event details render exception stack traces with in-app filtering, breadcrumbs, tags, and request/user context.

_app/views/projects/error\issues · high confidence

Introduce preview app management for project forks

Users can now manage preview apps within the project forks section. A new form allows configuring the fork status and selecting a deployment cluster via a rich select component. The index page displays existing preview apps and open pull requests, providing a direct action to create a preview app from a pull request.

_app/views/projects/project\forks · high confidence

Introduce structured account detail view model

Added a new \Api::Accounts::ShowViewModel\ that formats account data for API responses, including the account's ID, name, and slug. It also aggregates cluster-level details (ID, name, type) along with counts of visible projects and add-ons per cluster, providing a totals summary for clusters, projects, and add-ons accessible to the current user.

_app/view\models/api/accounts · high confidence

Introduce workbench UI with session management and setup progress

Users can now view and manage their development environment workbenches through a new interface. The show page displays a setup progress indicator that tracks repository cloning stages or reports errors, and renders a terminal view when a pod is active. A new modal provides a list of active shell sessions, showing session IDs, associated pod names, and connection times, allowing users to kill specific sessions directly from the UI. The session count badge updates in real-time via Turbo Streams to reflect the current number of connected sessions.

app/views/projects/workbenches · high confidence

Introduces account-based multi-tenancy and Pundit authorization

The application now supports multi-tenant accounts, allowing users to create, switch between, and manage multiple distinct accounts. This change introduces a new \AccountsController\ for account lifecycle management and updates \ApplicationController\ to track the active account via session, exposing \current\_account\ and \current\_account\_user\ helpers. To enforce security, Pundit authorization is integrated across the controllers, requiring users to have appropriate roles (e.g., owner or admin) to perform actions like updating account settings or managing resources within a specific account context.

app/controllers · high confidence

Introduces agent computers and buildpack search capabilities

This change introduces a new 'agent computer' feature, allowing users to provision isolated Kubernetes VMs (running Omarchy) for AI agent tasks, complete with session tracking, task scheduling, and real-time feed updates. It also adds the ability to search for and fetch details of CNCF buildpacks from the public registry, and provides a new cluster summary card component to display node CPU and memory usage statistics.

ruby · high confidence

Introduces background jobs for the agent loop lifecycle

Adds a set of background jobs to manage the agent's execution flow: TurnJob handles individual model turns with retry logic; BrowseWatchJob and DelegateWatchJob monitor long-running browser and coding tasks respectively; TidyActivitiesJob groups and titles session activities; WrapupJob generates session summaries and clears workspaces; and PostJob publishes session results to the user's feed.

_app/jobs/agent\sessions · high confidence

Introduces email notification system for account invites, service health, and general notifications

This change adds the core mailer infrastructure for the application, enabling email delivery for several key user events. Users will now receive account invitation and welcome emails via AccountInviteMailer and SignUpMailer. Additionally, the system can send service health alerts (down/restored) via ServiceHealthMailer, which includes inline branding assets and project favicons, as well as general build, deployment, and test notifications via NotifierMailer. The ApplicationMailer sets a default sender address and applies a standard mailer layout to these communications.

app/mailers · high confidence

Introduces internal auth proxy for projects, services, and add-ons

An internal authentication proxy has been added to secure communication between projects, services, and add-ons within the Kubernetes cluster. This new capability, implemented via the \K8::Stateless::AuthProxy\ service, manages OIDC issuer URLs (derived from \AppHost.url\) and OAuth application credentials to facilitate secure internal access.

app/services/k8/stateless · high confidence

Introduction of asynchronous view model base class

A new base class for asynchronous view models has been added to provide a standardized structure for handling async rendering. This class manages current user context and parameters, validates expected inputs upon initialization, and provides a helper method to render HTML partials using the application's renderer. It also includes a default error rendering method and a naming convention helper to derive view names from class names.

_app/view\models/async · high confidence

LDAP SSO provider configuration UI with connection testing

The LDAP Single Sign-On configuration interface now includes a dedicated form for setting up connection parameters (host, port, base DN, encryption, bind credentials) and optional advanced settings (UID, email, and name attributes). A new "Test Connection" button allows administrators to verify their LDAP settings before saving, providing immediate success or failure feedback via on-page status messages.

_app/views/accounts/sso\providers/ldap · high confidence

LDAP authentication service implementation

Added a new LDAP authenticator service that enables user login via LDAP directories. The service supports testing connection configurations independently of user login, handles both anonymous and bind-DN reader connections, and performs full authentication by verifying user passwords and optionally fetching group memberships. It supports plain, StartTLS, and SimpleTLS encryption methods and allows configurable user ID attributes and LDAP filters.

app/services/ldap · high confidence

New API Token management interface

Users can now create, view, and manage API tokens through a new settings page. The interface allows naming tokens and selecting an expiration preset (7, 30, 60, or 90 days) or a custom date. The token list displays names, masked access keys, last-used timestamps, and expiration dates, with a one-time visible full key upon creation and a clipboard copy feature. Tokens can be deleted directly from the list.

_app/views/api\tokens · high confidence

New API endpoint for managing project pods

A new controller has been added to expose pod management capabilities within the project API. Users can now list the first 50 pods in a project, retrieve details for a specific pod, create new pods via YAML configuration, and terminate existing pods through dedicated API endpoints.

app/controllers/api/v1/projects · high confidence

New Avo admin dashboard with statistics and filtering

A new dashboard view has been added to the Avo admin interface, providing a centralized overview of system health and activity. Administrators can now filter statistics by time period (7, 30, 90, or 365 days) and view key metrics including total users, accounts, clusters, projects, services, and add-ons. The dashboard displays performance indicators such as build and deployment success rates, service health, and cluster availability, along with status breakdowns for clusters and add-ons. Recent builds and deployments are listed with their current status, allowing for quick monitoring of ongoing operations.

app/views/avo/tools · high confidence

New Avo admin dashboard with statistics and navigation

Administrators now have a dedicated Dashboard page accessible via the Avo sidebar, featuring a suite of new statistics cards. These cards display key metrics including build and deployment success rates, counts of running and failed clusters, deployed projects, new apps, and new users, all rendered using new reusable stat and metric card components.

app/views/avo/custom · high confidence

New CLI execution, Docker registry, favicon, analytics, and schema inference services

This change introduces five new service classes in app/services to support core platform capabilities. The Cli service provides robust command execution with logging and the ability to kill running processes. DockerCli handles authentication for custom container registries, ensuring secure login/logout cycles. FaviconService fetches site icons using DuckDuckGo (default), Google, or direct URL checks. GoogleAnalytics enables asynchronous event tracking via GA4. Finally, InferJsonSchemaService automatically generates JSON schemas from sample data structures.

app/services · high confidence

New Helm-based deployment service with protected service auth proxy support

A new Helm-based deployment service has been introduced alongside a base deployment service and a legacy deployment service. The Helm service installs charts with atomic and wait flags disabled by default, registers manifests for tracking, and handles volumes, config maps, and secrets. For web services marked as protected, it now generates an AuthProxy resource, enabling internal authentication proxies for projects, services, and add-ons. Automatic DNS mapping is set up for auto-managed domains during deployment. The legacy service retains its previous behavior, including resource sweeping and manual restarts, while the base service provides shared logic for namespace setup, registry secrets, pre/post-deploy commands, and notification delivery.

app/services/deployments · high confidence

New Kubernetes integration layer for build clouds

This change introduces a new \K8\ service module that manages interactions with Kubernetes clusters for build cloud operations. It includes a connection handler that supports both in-cluster service accounts and external kubeconfigs (with localhost remapping), a client wrapper around the Kubeclient library for API calls, and a Kubectl wrapper that safely executes commands via temporary kubeconfig files. The \BuildCloudManager\ orchestrates the installation and lifecycle of BuildKit builders, handling namespace creation, builder bootstrapping, readiness checks, and image building. This provides the foundational infrastructure for deploying and managing remote build agents on Kubernetes.

app/services/k8 · high confidence

New Kubernetes node and pod metrics collection

The application now collects and stores CPU and memory usage metrics for Kubernetes nodes and pods. This is implemented via a new \K8::Metrics::Api\ module that retrieves data using \kubectl top\ and parses node/pod resource usage, while \K8::Metrics::Metrics\ aggregates this data and persists it to the cluster's metrics store. The collection process is resilient, continuing to gather metrics for other projects even if fetching metrics for a specific project fails.

app/services/k8/metrics · high confidence

New MCP prompts for project lifecycle and troubleshooting

Added five new MCP prompt templates in app/mcp/prompts that guide users through key Canine operations: deploying a new project (including add-on setup and environment variables), adding background workers or cron jobs, installing Helm chart add-ons, troubleshooting failing deployments, and handling destructive actions like resource deletion (which directs users to the web app). These prompts provide step-by-step instructions and API call sequences for managing the full project lifecycle via the MCP interface.

app/mcp/prompts · high confidence

New MCP tools for agent computer control and project management

Agents can now interact with cloud desktops and manage infrastructure through a new set of MCP tools. Computer control tools (computer\_accessibility, computer\_action, computer\_run, computer\_screenshot, computer\_terminal, computer\_windows) allow agents to navigate UIs via accessibility trees, execute mouse/keyboard actions, run shell commands, and manage windows. Project management tools (create\_add\_on, create\_cluster, create\_project, create\_service, deploy\_project, get\_add\_on\_logs, get\_cluster\_kubeconfig, get\_environment\_variable\_value, get\_error\_issue, get\_project\_logs, list\_agent\_computers, list\_error\_issues, restart\_project, search\_add\_ons, update\_environment\_variable, update\_error\_issue, update\_project) enable agents to provision clusters, deploy applications, manage services, view logs, handle error tracking, and update project configurations.

app/mcp/tools · high confidence

New OIDC authentication service implementation

A new OIDC authenticator service has been added to handle user authentication via OpenID Connect. This service manages the full authentication flow, including exchanging authorization codes for tokens, validating ID tokens using JWKS, extracting user claims (email, name, UID, groups), and falling back to the userinfo endpoint if necessary. It supports multiple JWT algorithms and includes caching for discovery documents and JWKS to improve performance.

app/services/oidc · high confidence

New Pod view model for status and navigation

A new PodViewModel class has been added to the application to handle the presentation logic for Kubernetes pods. This component provides methods to determine the pod's current status (such as running, pending, failed, waiting, or terminated) and extracts relevant status messages and reasons. It also generates the correct URL paths for viewing pod logs and accessing an online shell, adapting the routing based on whether the pod belongs to a Project or an AddOn.

_app/view\models · high confidence

New Processes interface for managing one-off pods

A new Processes section has been added to the project view, allowing users to create and manage one-off pods. The index page provides a button to launch single-instance pods for testing or temporary commands, while the show page displays pod logs and events. Users can also connect to these pods via a new modal that guides them through downloading a Kubeconfig file and copying the connection command, and a dedicated shell view enables interactive terminal access.

app/views/projects/processes · high confidence

New UI components for cluster summary, form fields, and selection controls

This change introduces several new ViewComponent classes to enhance the user interface for cluster management and form interactions. The ClusterSummaryCardComponent displays key Kubernetes cluster metrics, including node count, version, CPU, and RAM usage, along with error handling. The FormFieldComponent provides a standardized layout for form inputs with optional descriptions. Additionally, the RadioSelectCardComponent offers a styled radio button selection interface, and the RichSelectComponent provides a customizable, accessible dropdown select with support for custom rendering via partials, placeholders, and disabled states.

app/components · high confidence

New account management features: SSO, billing, teams, and stack managers

This change introduces several new capabilities for account administration. Users can now configure Single Sign-On (SSO) via OIDC, SAML, or LDAP through the new SSO providers controller, including an LDAP connection test feature. Account billing is gated behind cloud mode, utilizing Stripe for subscription management and portal access. The system now supports team management, allowing admins to create, edit, and destroy teams. Additionally, a new stack manager controller enables integration with Portainer and Rancher, including URL verification, connectivity checks, and syncing of clusters and registries. Finally, a new account users controller allows inviting existing or new users to an account, with email notifications sent if SMTP is configured.

app/controllers/accounts · high confidence

New account settings page with MCP access control

A new account edit view has been introduced, allowing users to update their account name and manage Model Context Protocol (MCP) permissions. The interface includes a toggle to enable or disable MCP access for the account, along with a link to open a modal providing instructions on how to add an MCP server.

app/views/accounts · high confidence

New action for creating stack managers with provider integration

A new StackManagers::Create action has been added to handle the creation of stack managers. This action ensures that a stack manager is created or retrieved for the account, assigns the provided parameters, and saves the record within a transaction. Additionally, it links the stack manager to the user by finding or initializing a provider record and associating it with the relevant access token (either a provided personal access token or the stack manager's own access token).

_app/actions/stack\managers · high confidence

New add-on creation flow with multi-source chart selection

Users can now create add-ons by selecting Helm charts from three sources: a searchable Artifact Hub index, a curated list of pre-configured charts, or a custom Helm/OCI repository. The new controllers handle fetching chart metadata and versions, displaying loading states on the submit button during data retrieval, and automatically populating the version selector once a chart is chosen.

_app/javascript/controllers/add\ons · high confidence

New agent keys management interface

A new 'Agent keys' settings page has been added, allowing users to view, add, and delete model provider API keys. The interface displays a list of existing keys with their provider, masked value, and last-used timestamp, and provides a form to securely store new keys in the database. A confirmation dialog warns users that deleting a key will stop any tasks currently using it.

_app/views/agent\_provider\keys · high confidence

New async search dropdown component with floating UI positioning

A new base controller for async search dropdowns has been added, providing a reusable component for search interfaces with autocomplete functionality. This controller integrates Floating UI to handle precise positioning of the dropdown menu relative to the input field, ensuring it stays visible during scrolling and resizing. It includes built-in debouncing for search inputs, loading states, and click-outside-to-close behavior, allowing child controllers to easily implement custom search logic by defining specific methods for fetching and rendering results.

app/javascript/controllers/components · high confidence

New billing page with per-cluster pricing and upgrade options

A new billing view has been added to the accounts section, allowing users to manage their subscription and billing details. The page displays the current plan, subscription status, and trial expiration if applicable. It introduces a per-cluster pricing model where the first cluster is free and additional clusters cost $20 per month, showing the count of billable clusters and the associated monthly cost. Users on the free plan can upgrade to Pro to get unlimited clusters, team members, priority support, and SSO/SAML authentication via a dedicated upgrade button. Existing Pro users with a Stripe integration can manage their billing, update payment methods, view invoices, or cancel their subscription through a link to the Stripe portal.

app/views/accounts/billing · high confidence

New build configuration form with Buildpacks support and cloud build options

The project build configuration interface has been redesigned to offer more flexible build options. Users can now choose between Dockerfile and Cloud Native Buildpacks as the build method; the Buildpacks option includes a dedicated UI for selecting a base builder and adding/removing buildpacks via a modal. The form also introduces a 'Build driver' selector allowing users to choose between Local Docker, Canine Cloud, or Kubernetes Build Cloud, with the latter providing a specific selector for Kubernetes clusters. Additionally, credential selection for container registries now uses a rich select component, and the image repository field is shown directly if already configured or hidden behind an expandable toggle otherwise.

_app/views/projects/build\configurations · high confidence

New buildpack and Dockerfile builder implementations for frontend services

Added two new builder classes, BuildpackBuilder and DockerfileBuilder, to handle frontend application builds. BuildpackBuilder executes Cloud Native Buildpacks via the 'pack' CLI, supporting ordered buildpacks, automatic build arguments (like GIT\_SHA and BUILD\_TIMESTAMP), and digest extraction from build reports. DockerfileBuilder uses Docker Buildx to construct images from Dockerfiles, supporting platform specification, automatic and custom environment variables as build arguments, and digest extraction from metadata files. Both builders integrate with the existing build infrastructure to provide standardized image building capabilities for frontend projects.

app/services/builders/frontends · high confidence

New cluster management actions and team-based access control

This change introduces a suite of new action classes in app/actions/clusters to handle cluster lifecycle operations, including creation, installation, YAML export, and filtering. It adds team-based visibility logic, restricting cluster access to users based on their team memberships and team resources, and implements a new installation workflow that syncs and installs components while sanitizing exported YAML to remove sensitive data.

app/actions/clusters · high confidence

New cluster management capabilities for build clouds, packages, and metrics

Users can now manage build clouds directly from the cluster interface, including installing, updating configuration (replicas, CPU/memory limits), refreshing status, and destroying them. The system also supports installing and uninstalling cluster packages via a new controller, along with a manual sync action to update package statuses. Additionally, a new metrics endpoint allows users to view sampled node metrics over a configurable time range (defaulting to 2 hours), with helper methods provided for parsing CPU and memory data for frontend rendering.

app/controllers/clusters · high confidence

New cluster metrics dashboard with live and historical views

Users can now view cluster resource utilization through a new metrics page. The dashboard features a live-updating table (refreshing every 30 seconds) that displays current CPU and memory usage for nodes, as well as per-pod resource consumption within namespaces. Additionally, a historical metrics section allows users to select time ranges (from 2 hours to 288 hours ago) and toggle between percentage and total display modes for CPU and memory usage charts.

app/views/clusters/metrics · high confidence

New cluster migration actions for add-ons and projects

Users can now migrate add-ons and projects between clusters using new dedicated action classes. The MigrateAddOn action duplicates the source add-on to the target cluster, assigns a unique name within the account, and sets its status to installing. The MigrateProject action orchestrates the migration by delegating to CanineConfig steps for creating definitions, restoring the project, and initializing it.

_app/actions/cluster\migrations · high confidence

New cluster setup instructions for Linux, macOS, Windows, DigitalOcean, and Linode

The cluster creation flow now includes dedicated, platform-specific instruction cards and step-by-step guides. Users can select their environment (Linux, macOS, Windows, DigitalOcean, Linode, or Other) to see tailored setup steps, including copyable commands for installing K3s/K3d and retrieving kubeconfig files, as well as direct links and screenshots for managed Kubernetes providers.

app/views/clusters/instructions · high confidence

New cluster type selection cards for K3s, Managed Kubernetes, and Local K3s

The cluster selection interface now includes dedicated UI cards for three distinct cluster types. Users can choose 'External K3s' for small projects on cloud providers like Hetzner ($4/mo), 'Managed Kubernetes' for larger projects on providers like Linode ($12/mo), or 'Local K3s or K3d' for free local development by uploading a kubeconfig file. Each card displays specific hardware recommendations and pricing to help users select the appropriate option.

_app/views/clusters/cluster\types/cards · high confidence

New credentials management interface for Git and container registries

Users can now manage provider credentials through a dedicated settings page that supports GitHub, GitLab, Bitbucket, and custom container registries (Docker Hub, GitHub Container Registry, Google GCR, AWS ECR, Azure ACR). The new interface allows adding credentials with provider-specific guidance for required scopes, configuring custom hostnames for enterprise Git servers, and managing Portainer access tokens. Existing credentials are displayed in a table showing usage status and associated projects, with protection against deletion if currently in use.

app/views/providers · high confidence

New deployment detail API view model

A new view model for the deployment show endpoint now exposes additional project and build context in the API response, including the build ID, commit SHA, and commit message. It also provides a direct link to the deployment view page, constructed using the project and build identifiers, allowing users to navigate directly to the specific deployment details from the API data.

_app/view\models/api/deployments · high confidence

New error event API view model with structured exception and breadcrumb data

The system now exposes a dedicated API view model for error events that structures exception chains, source context, tags, request details, and recent breadcrumbs for consumption by agents or clients. This change introduces a new \ErrorTracking\ module to safely parse varied SDK payload shapes and a \ShowViewModel\ that condenses raw event data into a consistent JSON format, limiting frames to 30 and breadcrumbs to 20 while preserving in-app frame prioritization and source line context.

_app/models, app/view\_models/api/error\events · high confidence

New error issue detail view model for API responses

A new ShowViewModel has been introduced for the error\_issues API area, defining the specific JSON structure returned when displaying a single error issue. This view model exposes key issue attributes including ID, short ID, title, culprit, level, status, platform, occurrence count, and release timeline data, ensuring consistent formatting for client applications consuming this endpoint.

_app/view\_models/api/error\issues · high confidence

New error tracking configuration interface with DSN management

Projects now have a dedicated configuration section for error tracking, providing a Sentry-compatible DSN that can be copied directly or used as an environment variable. The interface includes setup instructions for Ruby on Rails, Node.js, Python, and Browser environments, along with options to enable tracking, regenerate the DSN, or disable the feature entirely. When enabled, reported errors are grouped into issues and displayed on the project's Errors tab, with event retention governed by the system's configured policy.

_app/views/projects/error\_tracking\configurations · high confidence

New interface for managing cloud development environments

Users can now view and create managed cloud development environments directly from the project settings page. The new Development Environments index displays the project's template configuration (including target cluster, Dockerfile path, and workspace mount) and lists all active environments with their status, branch, and creator. A modal dialog allows users to create a new environment by selecting an existing Git credential, with an option to add new credentials if none are available.

_app/views/projects/development\environments · high confidence

New interface for managing project environment variables

Users can now manage environment variables for a project through a dedicated view that supports both individual creation and bulk import via .env file paste. The interface includes an 'Add new environment variable' button for single entries, a text area for pasting multiple key-value pairs, and a 'Download as .env' link to export current variables. The view utilizes a JavaScript controller to handle the dynamic addition of variables and form submission states.

_app/views/projects/environment\variables · high confidence

New model concerns for naming, billing, favorites, and team access

This change introduces several new model concerns in app/models/concerns that add foundational capabilities to the application. AccountUniqueName ensures names are unique within an account to prevent conflicts. Billable introduces plan-based limits for clusters and team members, along with subscription status tracking for Stripe billing integration. Favoriteable adds the ability for models to be favorited by users. Namespaced adds validation for namespace uniqueness within a cluster, reserves specific system namespaces, and ensures cluster migrations stay within the same account. TeamAccessible adds support for associating models with teams via team resources.

app/models/concerns · high confidence

New onboarding controller supporting multiple cluster integration methods

A new onboarding flow is now available that allows users to set up the application via three distinct methods: standard setup, Portainer integration, or Rancher integration. The controller automatically detects if the application is running in-cluster and, if so, fetches cluster node and version information using kubectl. It also includes logic to protect the onboarding routes if a user already exists, ensuring new installations can proceed while preventing re-onboarding for existing users.

app/controllers/local · high confidence

New onboarding flow with Portainer and Rancher integration options

The local onboarding experience has been expanded to support three installation methods: Normal, Portainer, and Rancher. Users can now choose to import from an existing Portainer or Rancher instance during setup, configuring provider URLs and API keys directly in the onboarding wizard. The flow also includes an account selection screen for existing accounts and allows users to opt out of cluster connection and build cloud installation in normal mode.

app/views/local · high confidence

New onboarding flow with optional in-cluster cluster and Build Cloud setup

The onboarding process now supports creating an in-cluster cluster and installing Build Cloud as part of the initial setup. When users opt-in during onboarding, the system creates a user and account, then conditionally provisions an in-cluster cluster with default or specified packages. If the user chooses to install Build Cloud, the system automatically creates and installs it on the new cluster. This replaces the previous separate install job trigger, integrating these steps directly into the onboarding action flow.

app/actions/onboarding · high confidence

New process shell interface with file upload and external connection guides

The processes view now includes a new terminal interface (\_terminal.html.erb) that supports drag-and-drop file uploads to pods and provides instructions for connecting via the Canine CLI or kubectl. A new pod listing partial (\_pods.html.erb) displays pod status, creation time, and actions like viewing logs, opening a shell, or deleting pods, with appropriate tooltips and disabled states for non-running pods.

app/views/processes · high confidence

New processes view for add-ons

Users can now view and manage processes within add-ons through a new set of views. The index page displays a list of pods using an asynchronous renderer, while the show page presents pod logs and events. Additionally, a shell view has been added to provide terminal access to pods, enhancing the ability to interact with and troubleshoot add-on processes directly.

_app/views/add\ons/processes · high confidence

New project fork and development environment creation workflows

This change introduces the backend logic for creating project forks and development environments. For project forks, the system now generates a configuration by inheriting the parent project's infrastructure settings while overriding project-specific attributes (name, branch) and merging script, service, and environment definitions from the pull request's \.canine.yml\. For development environments, it creates isolated instances that inherit the parent's build configuration (optionally using a custom Dockerfile), strip parent domains to assign new \oncanine.run\ domains, inject Git credentials and user details as environment variables, and provision a persistent workspace volume.

_app/actions/project\forks · high confidence

New project management controllers for services, deployments, and environments

This change introduces a comprehensive set of new controllers under \app/controllers/projects\ that expose core project management capabilities to users. Users can now manage project services (create, update, delete), handle deployments (redeploy, kill builds/deployments), and configure development environments (create, update, destroy configurations). Additional controllers enable managing project volumes, environment variables (with automatic restarts on update), metrics viewing, notifier configurations (including test sends), and preview apps via project forks. The \Projects::BaseController\ provides a shared \active\_connection\ helper for Kubernetes interactions, and controllers like \Processes\ and \Workbenches\ provide access to pod logs, shell access, and workbench status for development environments.

app/controllers/projects · high confidence

New project metrics dashboard with CPU and memory monitoring

Users can now view real-time and historical resource usage for their projects. The new metrics page displays live pod-level CPU and memory consumption in a table, alongside charts for aggregate CPU and memory usage over time. The interface supports asynchronous loading and includes search functionality to filter metrics by time range and display type.

app/views/projects/metrics · high confidence

New project uninstall services for Helm and legacy deployments

Users can now uninstall projects using dedicated service classes that handle resource cleanup more explicitly. The new \Projects::BaseUninstallService\ provides a standard uninstall workflow including pre/post-destroy commands and namespace deletion. Two concrete implementations are introduced: \Projects::HelmUninstallService\ for Helm-managed projects, which uses the Helm client to uninstall releases, and \Projects::LegacyUninstallService\ for legacy projects, which deletes specific Kubernetes resources (ConfigMap, Secrets, Deployment, CronJob, Service, Ingress, Pvc) labeled with \caninemanaged=true\.

app/services/projects · high confidence

New rake tasks for metrics, health checks, and Docker build management

Added new rake tasks to support operational monitoring and maintenance. The \metrics\ namespace provides tasks to check service health, fetch Kubernetes cluster metrics, and flush metrics older than a week. The \monitoring\ namespace includes a task to check for and kill Docker builds that have been running for more than one hour, helping to prevent resource exhaustion from hanging builds.

lib/tasks · high confidence

New scheduled jobs for system maintenance and demo management

This change introduces a suite of new background jobs in the \app/jobs/scheduled\ directory to handle routine maintenance and demo-specific logic. Key additions include \CancelHangingBuildsJob\ and \CancelHangingDeploysJob\ to automatically fail builds and deployments stuck in progress for over an hour, and \CheckForNewCommitsJob\ to trigger autodeploy checks for enabled projects. Demo mode support is enhanced with \ResetDemoProjectsJob\ and \ResetDemoAddOnsJob\, which reset projects and add-ons based on a configurable interval (defaulting to 24 hours) when Flipper's demo mode is enabled. Operational health is improved via \CheckHealthJob\ for service health checks, \FetchMetricsJob\ for cluster metrics, \FlushMetricsJob\ to clean up old metrics, \CleanupShellSessionsJob\ for stale shell tokens, and \SweepDnsRecordsJob\ to remove stale DNS records for auto-managed domains.

app/jobs/scheduled · high confidence

New service management controllers for domains, jobs, OAuth, and resource constraints

This change introduces a new controller hierarchy under \app/controllers/projects/services\ to handle specific service-level operations. A new \BaseController\ provides shared setup for project and service context. Dedicated controllers are added for managing service domains (creation, DNS checks, deletion), running and deleting manual Kubernetes jobs via kubectl, enabling/disabling Internal SSO and deploying service proxies, and creating, updating, or deleting resource constraints (CPU, memory, GPU limits/requests). These controllers replace or supplement previous ad-hoc handling, providing structured endpoints for these service configurations.

app/controllers/projects/services · high confidence

New shared UI components for forms, wizards, and async rendering

Added a suite of new shared view partials to enhance the user interface for configuration and deployment workflows. The new \_radio\_selector.html.erb provides a card-based selection interface with icons and descriptions, while \_namespace\_input\_group.html.erb introduces an expandable form for namespace configuration with an option for automatic creation. The \_markdown\_editor.html.erb adds a split-view editor with live preview, and \_async\_renderer.html.erb enables deferred rendering of view models. Additional components include \_progress\_stages.html.erb for visualizing multi-step workflows, \_namespace\_show.html.erb for displaying namespace details, and \_wizard\_animation.html.erb for decorative loading states.

app/views/shared/partials · high confidence

New shell-based installation and management scripts for Canine

Users can now install and manage the Canine application using two new shell scripts in the install directory. The \install.sh\ script automates the setup process by cloning the repository, verifying Docker and docker-compose availability, generating a secret key, pulling images, and starting the service on a configurable port (defaulting to 3456). The \canine\ script provides a convenient CLI interface to start, stop, or destroy the application environment, including automatic browser opening upon successful startup.

install · high confidence

New static marketing pages and interactive pricing calculator

The site now includes dedicated landing pages for Dev Environments, MCP Tools, and Self-Hosted deployment, along with a new interactive Cloud Provider Pricing Calculator. These pages provide users with detailed feature overviews, installation guides, and a tool to estimate costs across different cloud configurations.

app/views/static · high confidence

New user management tools in Avo admin panel

Administrators can now manage individual users directly from the Avo interface with four new capabilities: impersonate a user to view their experience, reset a user's password to generate a temporary one, disable two-factor authentication for users who have it enabled, and promote or demote users to site admin status. These tools are presented in a dedicated panel within the Avo resource view, streamlining common administrative tasks without needing to access the main application.

_app/views/avo/resource\tools · high confidence

New utility functions and Portainer connectivity checker

Added a new \debounce\ utility function in \app/javascript/utils/index.js\ to help manage frequent function calls. Introduced a \PortainerChecker\ class in \app/javascript/utils/portainer.js\ that provides methods to check URL reachability, verify general connectivity, and validate specific Portainer URLs with access tokens by communicating with backend endpoints like \/stack\_manager/check\_reachable\ and \/stack\_manager/verify\_url\.

app/javascript/utils · high confidence

New utility functions for rendering Helm chart UI components

Added a new JavaScript module in app/javascript/utils/helm\_charts/index.js that provides helper functions for rendering Helm chart information in the user interface. The module includes getLogoImageUrl to resolve chart logos from Artifact Hub, helmChartContent for generating HTML structure, helmChartHeader for dropdown items with constrained width, and renderHelmChartCard for displaying selected charts in a card format with close functionality.

_app/javascript/utils/helm\charts · high confidence

New view models for pod logs and events

Added EventViewModel and LogViewModel classes in the API pods namespace to structure pod-related data for JSON serialization. EventViewModel formats Kubernetes event details including type, reason, message, timestamps, and count. LogViewModel aggregates pod metadata, status, container state, logs, and events, optionally including a service name, providing a consistent API response structure for pod inspection.

_app/view\models/api/pods · high confidence

OIDC SSO provider configuration form

Added the user interface for configuring OpenID Connect (OIDC) single sign-on providers. The new form fields allow administrators to input the Issuer URL, Client ID, and Client Secret, along with optional scopes. Advanced settings are available in a collapsible section for manually specifying Authorization, Token, and UserInfo endpoints, as well as the JWKS URI. The form also supports customizing claim mappings for the user ID, email, and name, and displays the specific callback URL required for the OIDC provider configuration.

_app/views/accounts/sso\providers/oidc · high confidence

Portainer onboarding flow implementation

This change introduces the backend logic for onboarding a Portainer stack manager. It adds a series of LightService actions that handle authentication with the Portainer API, validate that the operation is not running in cloud mode, and orchestrate the creation of the user, account, and stack manager records in the database. The flow also triggers the initial synchronization of clusters and registries upon successful creation.

lib/portainer/onboarding · high confidence

Real-time interactive shell access to Kubernetes pods

Users can now open an interactive shell session directly within their browser to access containers running in Kubernetes pods. This new capability is powered by a dedicated ActionCable channel that manages the persistent WebSocket connection, handling terminal input/output, window resizing, and idle timeouts. The feature enforces security by validating session tokens and limiting the number of concurrent sessions per user, while automatically cleaning up stale connections and resources when the session ends.

app/channels · high confidence

Redesigned application layout and new email notification preferences

The application layout has been updated to use a new sidebar-based navigation structure with a dark theme, replacing the previous top-navbar design. A new 'Email Preferences' page allows users to manage service health alert notifications, and the email system now uses a dedicated mailer layout that includes a link to these preferences. Additionally, a PWA manifest and service worker have been added to support progressive web app features.

app/views/layouts · high confidence

Repository selection for GitHub and GitLab integrations

Users can now browse and select repositories from their connected GitHub and GitLab accounts. New controllers for both providers handle repository listing, supporting paginated views and client-side search filtering. The interface updates dynamically via Turbo Streams, refreshing the repository list and displaying the connected account username without a full page reload.

app/controllers/integrations · high confidence

SAML SSO configuration form for identity providers

Added a new user interface for configuring SAML Single Sign-On providers, allowing administrators to input essential identity provider details such as the Entity ID, SSO Service URL, and X.509 certificate. The form includes an optional advanced settings section for configuring Single Logout URLs, custom Service Provider Entity IDs, Name Identifier formats, and request signing requirements. It also provides fields for mapping SAML attributes to user identifiers, emails, names, and group memberships, alongside a helper panel that displays the required Assertion Consumer Service and Metadata URLs for the identity provider.

_app/views/accounts/sso\providers/saml · high confidence

SSO provider management UI now supports LDAP, OIDC, and SAML

The SSO provider settings page has been updated to allow users to create, edit, and view Single Sign-On configurations for three authentication protocols: LDAP, OpenID Connect (OIDC), and SAML 2.0. The new interface includes dedicated forms for each provider type, displaying specific configuration fields (such as Host/Base DN for LDAP, Issuer/Client ID for OIDC, and IdP Entity ID for SAML) and allowing users to enable/disable providers and configure team provisioning modes directly from the account settings.

_app/views/accounts/sso\providers · high confidence

Sentry-compatible error ingestion endpoint

A new ingest controller has been added to allow official Sentry SDKs to report errors directly to the application. It supports standard Sentry envelope formats and legacy JSON events, authenticating requests via the public key found in the DSN or authentication headers. This enables projects to integrate with existing Sentry tooling while keeping error data within the application's own infrastructure.

_app/controllers/error\tracking · high confidence

Stripe billing webhook handler gated by cloud mode

A new Stripe webhook controller has been added to process billing events, including checkout completions, subscription updates, and cancellations. This handler updates account plans and subscription statuses in the database but is strictly gated behind the \cloud\_mode\ configuration flag, ensuring it only activates in cloud deployments. It securely verifies Stripe signatures and handles specific event types to keep account billing data in sync with Stripe.

app/controllers/webhooks · high confidence

Support for Bitbucket, GitHub, and GitLab inbound webhooks

New job classes have been added to handle inbound webhooks from Bitbucket, GitHub, and GitLab. When a push event is received from any of these providers, the system identifies matching projects configured for auto-deploy and triggers a Docker build and deployment. An additional job handles the cleanup of processed webhook records.

_app/jobs/inbound\webhooks · high confidence

Support for GitHub, GitLab, and Bitbucket webhook integrations

The application now accepts inbound webhooks from GitHub, GitLab, and Bitbucket. Each provider has a dedicated controller that verifies the incoming event signature (using HMAC-SHA256 for GitHub and Bitbucket, and token comparison for GitLab) before persisting the payload and queuing it for asynchronous processing. This allows users to connect their repositories from these three services to trigger automated workflows.

_app/controllers/inbound\webhooks · high confidence

Support for bulk updating environment variables via text paste

Users can now update multiple environment variables at once by pasting text content (in NAME=VALUE format) into the interface. The system parses the input, creating new variables or updating existing ones based on their names, while removing any variables that are no longer present in the submitted list. This replaces the previous single-variable update mechanism with a comprehensive bulk operation that handles creation, modification, and deletion in a single transaction.

_app/actions/environment\variables · high confidence

Support for creating GitHub, GitLab, Bitbucket, and custom container registry providers

Users can now configure and validate credentials for GitHub, GitLab, Bitbucket, and custom container registries. The system validates access tokens and API scopes (skipping strict scope checks for enterprise instances), verifies connectivity, and generates the necessary Docker configuration JSON for authenticated registry access.

app/actions/providers · high confidence

Team member and resource management capabilities

Users can now manage team composition and access by adding or removing members and granting or revoking access to specific resources (clusters, projects, and add-ons). This change introduces the backend controllers to handle searching for available users within an account, creating and deleting team memberships, and managing team resource associations, enabling the UI to support these team administration workflows.

app/controllers/accounts/teams · high confidence

Team member management and invitation workflow

The Team Members settings page now allows administrators to view, manage, and invite users to the account. The member list displays user names, emails, roles, and 2FA status, with avatars, and enables admins to change roles or remove non-owner members. A new invitation flow lets admins add team members via email; if the user exists, they are added directly, otherwise credentials are generated and displayed in a modal with copy-to-clipboard functionality, and an invitation email is sent if SMTP is configured. The page includes pagination and respects plan limits for team member counts.

_app/views/accounts/account\users · high confidence

Teams management interface added

The Teams settings page now includes a complete user interface for managing team-based access control. Users can create and edit teams, view a list of all teams with member and resource counts, and assign granular permissions by adding specific Clusters, Projects, or Add-ons to each team. The interface features tabbed navigation for resources, search-based modals for adding members and resources, and an empty-state guide for new teams.

app/views/accounts/teams · high confidence

Removals

Removal of Madmin impersonation controller

The Madmin::ImpersonatesController has been removed, eliminating the ability for administrators to impersonate users via the Madmin dashboard. This change removes the \impersonate\ and \stop\_impersonating\ actions that previously allowed switching user identities within the admin interface.

app/controllers/madmin · high confidence

Security

Secure YAML configuration parsing and project restoration via CanineConfig

The system now uses a dedicated CanineConfig service to parse project configuration files, replacing previous methods with a safer approach that prevents arbitrary code execution by restricting template substitution to simple variable replacement (e.g., \<%= variable\_name %\>) instead of allowing full ERB evaluation. This change introduces new services for initializing project resources (services, environment variables, volumes, notifiers) from YAML definitions and for restoring projects from serialized configurations, ensuring that lifecycle scripts and deployment settings are applied securely during project creation and migration.

_app/services/canine\config · high confidence

Behavioural changes

1 commit (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1 commit, 9 files: “Let a credential's token be replaced, and refresh pull secrets on every project using it”.

app/jobs/providers · low confidence · unverified

API response structure refactored to use view models and partials

The JSON serialization for the Projects and Clusters API endpoints has been refactored to use dedicated view models and partials. Project list and show responses now delegate to \Api::Projects::ListViewModel\ and \Api::Projects::ShowViewModel\ respectively, while cluster responses use \Api::Clusters::ShowViewModel\. Additionally, pod details in the processes API are now rendered via a shared partial, standardizing the output format for pod metadata, status, and labels.

app/views/api/v1/projects · high confidence

Account-centric authentication and self-hosted registration controls

The user registration and login flows now automatically create a default account for new users, linking them as owners. Sign-up is disabled for self-hosted deployments, redirecting users to the login page instead. The login process now supports account-specific authentication via slugs, allowing users to log in directly to a specific organization's context. Additionally, the system now enforces TOTP two-factor authentication for logins when enabled, and the legacy Service model for social logins has been replaced by a Provider model to better support multiple SSO types like LDAP, OIDC, and SAML.

app/controllers/users · high confidence

Add URL and package details to cluster API response

The API response for cluster details now includes a direct link to the cluster's view page via the new \link\_to\_view\_url\ field, and provides expanded information about associated packages, including their ID, name, status, and installation timestamp.

_app/view\models/api/clusters · high confidence

Add domain job now uses Kubernetes connection objects

The new Services::AddDomainJob creates a K8::Connection object to handle Kubernetes interactions, replacing direct cluster access. This change introduces a connection-based approach for applying ingress YAML configurations, aligning with the broader shift from cluster objects to connection objects for Kubernetes integration.

app/jobs/services · high confidence

Add-on API responses now include cluster details, URLs, and service endpoints

The API for add-ons now returns richer data through new view models. The list endpoint includes cluster names and direct links to view each add-on. The show endpoint provides detailed project information, including repository URLs, internal and external service endpoints, and connection URLs, allowing users to see how add-ons are exposed and connected within the cluster.

_app/view\_models/api/add\ons · high confidence

Add-on management refactored into dedicated action classes with OCI and Artifact Hub support

The add-on installation and configuration logic has been restructured into a suite of dedicated action classes (e.g., \AddOns::Create\, \AddOns::InstallHelmChart\, \AddOns::ApplyEndpointIngress\) to improve maintainability and separation of concerns. This change introduces native support for Helm charts hosted in OCI registries (via \oci://\ URLs) alongside traditional HTTP repositories, and integrates with Artifact Hub for fetching chart metadata, versions, and values schemas. Additionally, the system now supports templated add-on values, allowing users to define dynamic configuration parameters that are processed during installation, and enforces namespace management rules to ensure add-ons are deployed to valid, isolated Kubernetes namespaces.

_app/actions/add\ons · high confidence

Add-on management refactored into dedicated controllers with new capabilities

The add-on management interface has been restructured into specific controllers (Endpoints, Metrics, OAuth Applications, Processes, Cluster Migrations) inheriting from a new base controller that standardizes Kubernetes connection handling. This change introduces several new user-facing capabilities: users can now migrate add-ons to different clusters via a dedicated migration flow, enable or disable internal SSO protection for add-ons, view historical metrics even if the cluster is temporarily unreachable, and access pod logs and events with improved error handling for missing resources. Additionally, an online shell feature has been added for debugging pod processes, and endpoint configuration now includes validation for domain formats and port mappings.

_app/controllers/add\ons · high confidence

Add-ons API now uses view models for JSON serialization

The API responses for listing and showing add-ons have been refactored to use dedicated view models (Api::AddOns::ListViewModel and Api::AddOns::ShowViewModel) instead of direct object serialization. This change centralizes the JSON structure logic for the add-ons index and show endpoints, ensuring consistent data formatting for API consumers.

_app/views/api/v1/add\ons · high confidence

Add-ons management UI overhaul with install tracking and migration

The add-ons interface has been rebuilt to provide a comprehensive management experience. Users can now install add-ons via a new creation flow that supports chart selection, versioning, and YAML configuration with autocomplete. During installation, a dedicated layout displays a multi-stage progress tracker and allows users to view real-time logs. The edit page now includes a cluster migration tool to copy an add-on to a different cluster, alongside standard configuration and deletion options. The main index view presents add-ons in a sortable table, and the show view features a tabbed sidebar for navigating Info, Processes, Metrics, and Settings.

_app/views/add\ons · high confidence

Added DNS verification for ingress domains

Users can now automatically verify the DNS status of domains associated with their ingress resources. A new \Networks::CheckDns\ action performs live DNS lookups (A or CNAME records) to confirm that the domain points to the expected IP address or hostname, updating the domain status to either 'dns\_verified' or 'dns\_incorrect' with a specific reason if the record does not match.

app/actions/networks · high confidence

Admin panel migrated to Avo with comprehensive resource definitions

The admin interface has been switched to the Avo framework, introducing a complete set of resource definitions for managing system entities. Administrators can now view and search Accounts, Projects, Clusters, Teams, and Users, with detailed views for Build logs, Deployments, and Services. The update also adds configuration resources for SSO providers (OIDC, SAML, LDAP), allowing admins to manage authentication settings, alongside resources for Add-ons, Domains, and Development Environments.

app/avo · high confidence

Admin panel migration to Avo with new management capabilities

The admin interface has switched from Active Admin to Avo, introducing a new dashboard and resource controllers for managing accounts, builds, clusters, projects, teams, and users. Administrators can now impersonate users, reset user passwords with temporary credentials, disable two-factor authentication, and promote or demote users to site admin status directly from the panel.

app/controllers/avo · high confidence

Async loading and dual metric support for cluster metrics

The cluster metrics view now loads asynchronously using Turbo Frames to improve page responsiveness, and displays both CPU and Memory usage charts. The view utilizes a dedicated view model to handle data preparation and includes a search partial to allow users to filter or configure the metric display.

_app/views/add\ons/metrics · high confidence

Async loading for Helm add-on details

The Helm add-on details page now loads specific sections asynchronously to improve perceived performance. New view models handle the async retrieval and rendering of the internal URL, storage metrics, Helm chart version, and the values YAML configuration. The values YAML view specifically renders the configuration as a table with a toggleable password mask for sensitive entries, while other sections display skeleton loaders or spinners during the fetch.

_app/view\models/async/helm · high confidence

Async rendering of Kubernetes cluster and service details

The Kubernetes dashboard now loads cluster information (server version, server address), node metrics (CPU and memory usage for nodes and pods), service cluster IPs, and certificate status asynchronously. This change improves perceived performance by showing loading spinners immediately and fetching data in the background, while also introducing a new view for certificate issuance status and refining the node metrics table to display both node-level and per-namespace pod-level resource usage.

_app/view\models/async/k8 · high confidence

Automatic HTTPS prefix for APP\_HOST configuration

The application now automatically prepends 'https://' to the APP\_HOST environment variable if it does not already start with 'http'. This allows users to configure APP\_HOST with either a bare hostname or a full URL, ensuring consistent behavior for error tracking and other services that rely on this host value.

app/lib · high confidence

Cluster packages now skip installation if components are already present

The cluster package installers for cert-manager, Traefik ingress, and KubeVirt now check whether the respective components are already installed on the cluster before attempting to install them. If a component is detected as present, the installation is skipped with an informational message, allowing reuse of existing installations rather than forcing a fresh install or failing due to conflicts.

_app/models/cluster\package · high confidence

Custom OAuth authorization UI with PKCE support

The application now provides custom views for the Doorkeeper OAuth flow, replacing the default interface with a styled card-based layout. Users will see a new authorization screen that clearly displays the requesting client's name and the specific scopes being requested, along with explicit 'Authorize' and 'Deny' buttons. The flow now supports PKCE (Proof Key for Code Exchange) by passing code challenge parameters in the authorization request. Upon successful authorization, a dedicated success page displays the generated authorization code for the client to use.

app/views/doorkeeper · high confidence

Custom Turbo confirmation modals and removal of Bootstrap UI components

The application now uses a custom HTML dialog for form confirmations via Turbo, replacing the previous default browser alerts with a styled modal that supports dynamic titles and button types. This change is accompanied by the removal of Bootstrap's tooltip and popover initialization logic from the main application entry point, while adding Chartkick integration for data visualization.

app/javascript · high confidence

Customized Avo admin panel styling and branding

The Avo admin panel now features a dark mode theme with colors matched to the core application, uses the DM Sans font family for consistency, and displays a 'Site Admin' label in the header. The footer has been updated to show 'Canine, Inc.' branding instead of the default Avo attribution, and link colors have been adjusted to use a subtle indigo accent.

app/views/avo/partials · high confidence

Display historical metrics when cluster is unreachable

The metrics view now renders historical data even if the cluster is unreachable, ensuring users can still see past metrics instead of being blocked by connectivity issues.

_app/view\_models/async/add\ons/metrics · medium confidence

Expanded API project and build view models with detailed metadata

The API response structures for projects and builds have been significantly enriched. The project show view model now includes detailed configuration fields such as autodeploy settings, Docker build paths, pre/post-deploy commands, and a new error tracking DSN. It also exposes comprehensive lists of associated services (including domains and health checks) and volumes, along with the ten most recent builds. The builds themselves are now represented by dedicated view models: the list view provides a concise summary with a tail of the last 10 log lines, while the show view includes full logs, deployment details, and manifest information.

_app/view\models/api/projects · high confidence

Global search results UI for projects, clusters, and add-ons

The search interface now displays results for projects, clusters, and add-ons using a consistent, styled list layout. Each result type includes a relevant icon or logo, the item name with query highlighting, and contextual metadata such as the cluster name, project repository URL, or associated project/add-on counts. Results are grouped by type with section headers and updated dynamically via Turbo Streams.

app/views/search · high confidence

Improved mobile keyboard experience for email input fields

The email input fields on the confirmation and unlock pages now include the inputmode attribute set to 'email'. This change ensures that mobile devices present the optimized email keyboard layout when users type their email addresses, improving usability and reducing typing errors on touchscreens.

app/views/devise/confirmations, app/views/devise/unlocks · high confidence

Initial Rails 8 environment configuration files added

The application now includes explicit configuration files for development, production, and test environments, marking the completion of the Rails 8 upgrade in this area. In development, code reloading is enabled, mailers use the letter\_opener delivery method for local previewing, and ngrok hostnames are permitted for tunneling. Production mode enforces SSL by default (with exceptions for local or cluster modes), logs to STDOUT, and dynamically configures allowed hosts based on the ALLOWED\_HOSTNAME environment variable to support Kubernetes deployments. The test environment isolates storage and jobs, disables forgery protection, and configures GoodJob to avoid persisting job records.

config/environments · high confidence

Internal SSO proxy configuration now enforces HTTPS redirect URIs

The internal SSO logic has been refactored into dedicated actions that manage OAuth application creation and proxy deployment. A key behavioral change is that redirect URIs for both services and add-ons are now explicitly constructed with the 'https://' scheme (e.g., 'https://{domain}/oauth2/callback'), ensuring secure callback endpoints. Additionally, the system now normalizes the base application host to handle both bare hostnames and full URLs when generating these URIs.

_app/actions/internal\sso · high confidence

Introduce MCP resource-based access for accounts, projects, and add-ons

The MCP server now exposes a structured set of resources under the \canine://\ namespace, replacing previous tool-based interactions with URI-addressable data endpoints. Users can now retrieve account lists, project details, build histories, environment variable metadata, cluster information, and add-on configurations via specific URIs (e.g., \canine://accounts/{id}/projects/{pid}/builds\). Access is strictly scoped to accounts where \allow\_mcp\ is enabled, and the server provides a schema resource to document available endpoints and templates.

app/mcp/resources · high confidence

Introduce dedicated controller for managing Portainer API tokens

Users can now explicitly manage their Portainer API access tokens through a new dedicated controller. This change introduces a specific workflow for updating and removing individual Portainer credentials, replacing the previous stack-manager-based authentication approach. The new flow validates the token against the Portainer API, stores the access token and associated username, and clears any cached token state upon update or removal, ensuring that only accounts with Role-Based Access Control (RBAC) enabled can utilize this individual credential management feature.

app/controllers/providers · high confidence

Introduce shared concerns for MCP tool authentication and agent computer access

Added two new Ruby concerns to the MCP tools layer to standardize how tools handle user context and interact with agent computers. The \Authentication\ concern provides helper methods to resolve the current user and their account access, including checks for MCP enablement and project/computer visibility. The \AgentComputerAccess\ concern offers a shared interface for tools to locate a running agent computer, manage the computer-use server connection, and format responses (including screenshots) consistently. These changes refactor common logic out of individual tools to ensure consistent access control and error handling across the expanded MCP toolset.

app/mcp/tools/concerns · high confidence

Introduces structured project lifecycle actions and a live diagnostic system

This change replaces ad-hoc project logic with a suite of dedicated action classes (using LightService) that manage the project creation, update, and deployment workflows. Key additions include \Projects::Create\ and \Projects::Update\ which orchestrate source configuration, build configuration, and namespace setup; \Projects::DeployLatestCommit\ which supports skipping builds to reuse previous deployment digests; and \Projects::Doctor\, which provides a live, Turbo Stream-based diagnostic modal to check cluster connectivity, source repository access, registry authentication, and build cloud status. The diff also introduces \Projects::VisibleToUser\ to enforce team-based project visibility and \Projects::Filter\ for search functionality.

app/actions/projects · high confidence

Introduction of comprehensive view helpers and removal of Bootstrap styling

The application introduces a wide range of new helper modules to support UI rendering and data processing, including \AddOnsHelper\ for add-on layouts and logo URLs, \ApplicationHelper\ for custom Pagy pagination and color generation, \AvoDashboardHelper\ for status-based color styling, \ClustersHelper\ for cluster-specific icons, \LogColorsHelper\ for converting ANSI codes to Tailwind classes, \MetricsHelper\ and \NamespaceMetricsHelper\ for sampling and parsing CPU/memory metrics, and \StorageHelper\ for converting between integer and human-readable compute/memory units. Additionally, \TurboStreamActionsHelper\ adds custom Turbo Stream actions, while \Eventable\ and \Loggable\ concerns provide event tracking and structured logging capabilities. As part of this shift, the legacy \BootstrapHelper\ has been removed, indicating a migration away from Bootstrap CSS classes in favor of the new Tailwind-based styling infrastructure.

app/helpers · high confidence

Landing page redesigned with new sections and interactive demos

The landing page has been completely rebuilt with a new dark-themed layout, featuring a hero section, a CLI demo using Asciinema, and dedicated sections for features, Kubernetes self-hosting, and pricing. The page now includes an interactive MCP terminal animation, a cost comparison chart, and a swipeable card stack for mobile. Navigation has been updated with dropdowns for Product and Resources, and the footer now links to a Cost Calculator, Privacy, and Terms pages.

_app/views/static/landing\page · high confidence

Migrate styling to Tailwind CSS and add component assets

The application's styling system has been replaced with Tailwind CSS, introducing a new \application.tailwind.css\ entry point that imports base, component, and utility layers alongside specific libraries like Tippy.js and xterm.js. This change adds comprehensive styles for UI components, including navigation, pagination, forms, tables, and custom alerts/badges, while removing legacy SCSS files such as \jumpstart/announcements.scss\. Additionally, new asset directories for builds and images have been created, and specific styles for ApexCharts and a Pacman loading animation have been added to support new visual features.

app/assets · high confidence

New actions for saving development environment configurations and destroying development environments

This change introduces two new action classes to handle specific lifecycle operations for development environments. The \DevelopmentEnvironmentConfigurations::Save\ action now encapsulates the logic for persisting configuration changes, ensuring that save failures are properly reported. Additionally, the \DevelopmentEnvironments::Destroy\ action provides a dedicated mechanism for removing development environments, which includes disconnecting parent-child fork relationships by destroying associated records. These actions streamline the backend logic for managing the creation and deletion of development environments.

_app/actions/development\_environment\configurations · high confidence

New endpoint management UI with SSO protection and ingress support

The add-ons section now features a dedicated interface for managing service endpoints, displaying both internal cluster URLs (with a telepresence setup guide) and external URLs derived from ingress configurations. Users can edit endpoint domains via a new form that validates DNS records (A or CNAME) and provides copy-to-clipboard functionality for DNS values. Additionally, this view introduces the ability to enable or disable Canine SSO protection directly on the endpoint edit page, replacing the previous internal toggle mechanism.

_app/views/add\ons/endpoints · high confidence

New generic chart component with Stimulus controller

A new shared partial \\_chart.html.erb\ has been introduced to render charts using a \data-controller="chart"\ Stimulus component. This component accepts a configuration object via \data-chart-config-value\ and displays a title and a 400px high container, replacing the previous charting implementation.

app/views/shared/charts · high confidence

New log viewing interface with live streaming and error handling

The log output views have been replaced with new partials that provide a structured, styled interface for viewing logs. Users can now see logs for general resources via a paginated list (limited to the most recent 100 entries) and for pods via a dedicated view that includes a 'LIVE' indicator for real-time updates. This new pod view also displays startup logs derived from pod events, shows error alerts if log retrieval fails, and offers a link to add an MCP server for debugging assistance.

_app/views/log\outputs · high confidence

New project lifecycle jobs for builds, deployments, and destruction

This change introduces a new set of background jobs to manage the project lifecycle, replacing previous inline or less structured logic. Users will now experience distinct, queued operations for building projects (supporting Kubernetes, Docker, and Cloud drivers), deploying via Helm or legacy methods, and destroying projects with retry logic for Helm uninstalls. Additionally, a new doctor job provides concurrency controls for diagnostics, and a demo reset job handles periodic updates for demo-mode projects.

app/jobs/projects · high confidence

New project update forms for Git and Container Registry configurations

The project update interface now uses dedicated form templates for configuring Git repositories and container registries. The Git form allows users to select credentials via a rich select component, specify a branch, enable autodeploy, and optionally configure build settings when the feature is enabled. The Container Registry form provides fields for the repository path, image tag, and predeploy command, while automatically indicating whether credentials are required based on the image's public status. Both forms include submission feedback and consistent error handling.

app/views/projects/update · high confidence

New settings layout with SSO login URL and conditional billing access

The settings interface now uses a new shared layout that displays a copyable Account Login URL for users with an SSO provider and organizes navigation into User and Account sections. The menu includes links to Profile, Credentials, Notifications, General settings, Team Members, Authentication, and Stack Manager. Billing access is now gated behind the cloud\_mode configuration flag, meaning it only appears for users in cloud mode.

app/views/settings · high confidence

Rails 7.2 upgrade and configuration overhaul

The application has been upgraded to Rails 7.2, bringing updated defaults and improved performance. Configuration is now driven by environment variables, supporting local, cloud, and cluster boot modes, with specific settings for passwordless local authentication and account-only sign-in. The Action Cable adapter has been migrated from Redis to the enhanced PostgreSQL adapter, removing the Redis dependency for real-time features. Additionally, the UI theme has been updated to use DaisyUI with custom light and dark color palettes, and the sitemap has been expanded to include new pages like the pricing calculator and LLMs.txt.

config · high confidence

Redesigned account management UI with integrated two-factor authentication

The account settings and authentication views have been completely restyled using a modern card-based layout with Tailwind CSS and DaisyUI components, replacing the previous Bootstrap structure. The account edit page now features distinct sections for Profile, Authentication, and a Danger zone, and explicitly hides password change fields for users who signed in via GitHub OmniAuth. A new two-factor authentication setup and management interface has been added, allowing users to enable, disable, and view the status of 2FA directly within the account settings. The sign-up and password reset pages have also been updated to match this new visual design.

app/views/devise/registrations · high confidence

The shared authentication links component now prominently features social sign-in buttons for configured OmniAuth providers (such as GitHub) instead of simple text links, and includes an expandable section explaining why GitHub OAuth permissions are required for container registry access. Additionally, password recovery and confirmation links have been updated to use internationalized text keys and styled as block-level elements for better visual hierarchy.

app/views/devise/shared · high confidence

Redesigned cluster management interface with new lifecycle and configuration features

The clusters section has been completely rewritten with a new layout, sidebar navigation, and status indicators. Users can now create clusters with support for local K3s, K3s, and standard Kubernetes providers, and manage them via a unified dashboard. Key additions include the ability to download kubeconfig files and export Kubernetes YAML manifests (with options to include ConfigMaps and masked Secrets), transfer cluster ownership between accounts, and rerun or retry cluster installations. The edit view allows updating cluster names, skipping TLS verification, and editing kubeconfig credentials directly. The interface also displays system packages (recommended and optional), project and add-on grids, and install logs, while the index page supports pagination and Portainer syncing.

app/views/clusters · high confidence

Redesigned deployment tracking with real-time updates and Kubernetes manifest inspection

The deployments interface has been rebuilt to provide a comprehensive, real-time view of build and deployment events. The index page now lists events with commit details, status badges (including a pending spinner), and timestamps, updating live via Turbo Streams. The show page offers deeper visibility: it displays build and release logs, allows users to kill in-progress builds or deployments, and provides a 'Run Diagnostics' button for failed events. Additionally, a new manifest browser lets users view the Kubernetes manifests associated with a deployment, enhancing transparency into what was actually deployed.

app/views/projects/deployments · high confidence

Redesigned error pages and added AI documentation assets

The public-facing error pages (404, 406, 422, and 500) have been completely redesigned with a dark theme, responsive layouts, and unique illustrations for each error state. The 404 page now features a floating image illustration. Additionally, an \llms.txt\ file has been added to provide structured documentation for AI models, and a new \icon.svg\ placeholder has been introduced.

public · high confidence

Redesigned login interface with multi-provider support and account selection

The login experience has been completely overhauled to support multiple authentication methods and account management. The main sign-in page now features a modern card-based layout with Tailwind CSS styling, includes a link to sign up, and conditionally displays a Portainer stack manager badge. New dedicated views have been added for LDAP, OIDC, and SAML authentication, allowing users to sign in via their organization's identity provider. Additionally, a new account selector component enables users to choose between different accounts, displaying specific login options such as passwordless access, SSO providers, or standard password login based on the account's configuration.

app/views/devise/sessions · high confidence

Redesigned project creation flow with Git and Container Registry options

The project creation interface has been restructured into two distinct paths: deploying from a Git repository (supporting GitHub and GitLab) and deploying from a container registry (public or private). The new forms introduce a 'RichSelectComponent' for cluster selection, explicit credential selection via a new 'select\_credentials' partial, and specific fields for image sources, predeploy commands, and build settings. Users are now guided through dedicated views for missing Git or registry credentials, with clear navigation links to switch between deployment types or add necessary integrations.

app/views/projects/create · high confidence

Redesigned project management interface with real-time updates and new capabilities

The project views have been completely overhauled to provide a modern, responsive interface. The project index now displays a table with real-time status updates via Turbo Streams, showing the latest commit SHA and deployment details. The main project layout includes a new header that distinguishes between standard projects, forked preview apps, and development environments, along with a favicon that fetches the site icon via DuckDuckGo. Users can now manage development environment configurations directly from the edit page, including setting target clusters and Dockerfile paths. The interface also supports cluster migration, allowing users to move projects to different clusters, and includes a 'Run Diagnostics' button for troubleshooting. The sidebar has been reorganized to include tabs for Workbench, Deployments, Services, Environment, Processes, Metrics, and Preview Apps, with conditional visibility based on project type and feature flags.

app/views/projects · high confidence

Redesigned resource constraints UI with sliders and enable toggles

The resource constraints interface for services has been replaced with a new form layout featuring dedicated CPU and Memory sections. Each resource type now includes a checkbox to enable/disable the constraint and a range slider (0.1–16 cores for CPU, 128–32768 MB for Memory) alongside a numeric input for precise values. The form supports both creating new constraints and updating existing ones, with appropriate submit buttons and a delete option for persisted constraints.

_app/views/projects/services/resource\constraints · high confidence

Redesigned service management interface with tabbed navigation and SSO protection

The service management UI has been restructured into a tabbed layout (Overview, Networking, Cron Job History, Advanced) to organize configuration options. Users can now enable Canine Single Sign-On (SSO) protection for web services via the Networking tab, which deploys an OAuth2 proxy. The Advanced tab allows editing resource constraints and custom pod template YAML, while the Overview tab consolidates settings for container ports, health checks, replicas, and descriptions. A new Cron Job History tab displays run logs, durations, and statuses, and the service index now includes a Telepresence guide for connecting to private services.

app/views/projects/services · high confidence

Redesigned user interface with Tailwind CSS and new diagnostic tools

The application's user interface has been completely overhauled, migrating from Bootstrap to Tailwind CSS and replacing Font Awesome icons with Iconify. This update introduces a new global search modal, a redesigned navigation bar, and a new password change flow. Additionally, a project 'doctor' system has been added to provide live diagnostic checks and resolution hints during builds, alongside a new MCP modal for AI tool integration and an admin right navigation for managing feature flags and jobs.

app/views/shared · high confidence

Refactor service creation and updates into dedicated action classes

Service creation and update logic has been moved from model callbacks to dedicated action classes (Services::Create, Services::Update, etc.) using the LightService library. This change centralizes the handling of service associations, cron schedule updates, and auto-managed domain attachment, ensuring that these side effects are executed explicitly during service lifecycle operations rather than implicitly through model callbacks.

app/actions/services · high confidence

Refactored API build views to use view models

The JSON serialization logic for the builds API has been refactored to use dedicated view models. The show and index endpoints now delegate to a shared partial, which in turn utilizes the \Api::Builds::ShowViewModel\ to structure the build data, replacing the previous inline serialization logic.

app/views/api/v1/builds · high confidence

SSO provider configuration logic refactored into dedicated action classes

The logic for creating and updating SSO provider configurations has been restructured into a set of dedicated action classes within the \app/actions/sso\_providers\ directory. This change introduces \BuildSSOConfiguration\ to handle the instantiation of specific configuration objects (LDAP, OIDC, SAML) based on the provider type, and \SaveConfiguration\ to persist both the configuration and the provider record. Additionally, \Create\ and \Update\ organizers orchestrate these steps, while \UpdateConfiguration\ handles the specific logic for modifying existing configurations. This refactoring centralizes the behavior for managing SSO provider settings.

_app/actions/sso\providers · high confidence

SSO user and team synchronization logic

The application now includes specific actions to handle SSO user creation and team synchronization. When a user logs in via SSO, the system attempts to link the user to an existing account by SSO provider identity or email, creating a new user record if necessary and updating their name. Additionally, the system can automatically create teams within the account based on remote team names and synchronize the user's team memberships, adding them to remote teams and removing them from local teams they are no longer part of in the remote source.

app/actions/sso · high confidence

Scheduled agent task execution via background job

A new background job (AgentTasks::ScheduleJob) now runs every minute to check for due agent tasks and start their sessions. It ensures tasks only run if the associated computer is active and the account has the feature enabled, using concurrency controls to prevent duplicate scheduling and locking to avoid race conditions when starting sessions.

_app/jobs/agent\tasks · high confidence

The service down and restored email templates have been updated to clearly display the associated project and service names, along with the specific health check URL when available. Each notification now includes a direct "View Service" button that links to the service's detail page, allowing users to quickly investigate the status without navigating manually.

_app/views/service\_health\mailer · high confidence

The sidebar layout has been refactored to introduce a 'favorites' section for Projects, Clusters, and Add-ons, displayed alongside a full list of all items. Additionally, when the Agent Computer feature is enabled for the account, a new 'Agent Computers' section is added to the sidebar, listing up to 10 computers and providing a link to create new ones. The sidebar now dynamically switches between a 'favorites' view and a 'full' view based on the SCALE\_MODE environment variable.

app/views/layouts/sidebars · high confidence

Simplified auto-managed domain naming for single-service projects

The system now generates simpler domain names for projects containing only one public web service, using the format {project\_slug}.oncanine.run instead of {service\_name}-{project\_slug}.oncanine.run. This change is implemented via the new Domains::AttachAutoManagedDomain action, which checks the count of public web services in a project to determine the naming convention, and includes corresponding cleanup logic in Domains::Destroy to remove associated DNS records when auto-managed domains are deleted.

app/actions/domains · high confidence

Stack manager now verifies Portainer connectivity with RBAC-aware status feedback

The stack manager UI now actively validates Portainer instance connectivity when configuring stacks. A new badge controller automatically checks reachability on load, distinguishing between general URL reachability and authenticated access when RBAC is enabled, displaying specific success, error, or unauthorized states. Additionally, a new URL input controller allows users to manually verify their Portainer URL and access token, providing immediate feedback on whether the instance is reachable and if the provided credentials are valid, helping users troubleshoot connection issues before deploying stacks.

_app/javascript/controllers/stack\manager · high confidence

Standardized API response structures for environment variables, providers, and Helm charts

Introduced dedicated view models to define the JSON structure for API responses, ensuring consistent and explicit data shaping for clients. Environment variable responses now explicitly mask values unless revealed or the variable is a config type. Provider responses now include specific boolean flags indicating Git integration, native container registry support, and enterprise status. Helm chart responses are split into curated and hub result formats, with curated charts exposing template details and hub results including Artifact Hub identifiers.

_app/view\_models/api/environment\_variables, app/view\_models/api/helm\_charts, app/view\models/api/providers · high confidence

Fixes

Added development credential key

A new development key file (development.key) has been added to the config/credentials directory, containing a specific hexadecimal value for local environment authentication or configuration.

config/credentials · low confidence

Test coverage

Added test coverage for add-on, buildpack, cluster, and migration actions; Removed template integration test.

Dependencies

159 commits updating dependencies (4 manifests)

A dependency / build maintenance change in (dependencies) — 159 commits (5 fixs), 4 files.

(dependencies) · medium confidence · unverified

Housekeeping

Added placeholder files for standard directories

Empty .keep files were added to the lib/assets, log, storage, tmp, tmp/pids, and tmp/storage directories. This ensures these directories are tracked by version control and exist in the repository structure, which is a common practice in Ruby on Rails applications to maintain directory persistence across deployments or when using Git.

(repo-wide) · 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 40 → 40 (-0.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 33 → 33 (+0.0)
  • Architecture 87 → 87 (+0.0)
  • Maturity 61 → 67 (+5.6)
  • Readiness 43 → 43 (+0.0)
  • Security 60 → 56 (-3.7)
  • Domain Modelling 52 → 52 (+0.0)
  • Accessibility 38 → 38 (-0.1)
  • Performance 100 → 100 (+0.0)

Resolved (15)

  • Documentation: no project overview (README.md)
  • High CVE: [GHSA redacted] (yarn.lock)
  • High CVE: [GHSA redacted] (yarn.lock)
  • High CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • No AppArmor/SELinux confinement (resources/k8/add_ons/auth_proxy.yaml)
  • No AppArmor/SELinux confinement (resources/k8/shared/metrics_server.yaml)
  • No AppArmor/SELinux confinement (resources/k8/stateless/auth_proxy.yaml)
  • No AppArmor/SELinux confinement (resources/k8/stateless/command.yaml)
  • No AppArmor/SELinux confinement (resources/k8/stateless/cron_job.yaml)
  • No AppArmor/SELinux confinement (resources/k8/stateless/deployment.yaml)
  • No AppArmor/SELinux confinement (resources/k8/stateless/pod.yaml)
  • Outdated: devise_invitable
  • Outdated: net-ssh

New (15)

  • High CVE: [GHSA redacted] (yarn.lock)
  • High CVE: [GHSA redacted] (yarn.lock)
  • High secret: WD-SECRET-0005 (helm/canine/output.txt)
  • High secret: WD-SECRET-0005 (helm/canine/output.txt)
  • Medium CVE: [GHSA redacted] (Gemfile.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • No seccomp profile (resources/k8/add_ons/auth_proxy.yaml)
  • No seccomp profile (resources/k8/stateless/auth_proxy.yaml)
  • Outdated: omniauth
  • Outdated: rotp
  • redundant comment (app/javascript/controllers/add_ons/artifact_hub_search_controller.js)
  • redundant comment (app/javascript/controllers/components/async_search_dropdown_controller.js)
  • redundant comment (app/javascript/controllers/manifest_browser_controller.js)
  • redundant comment (app/javascript/controllers/yaml_editor_controller.js)

Changes since last survey

  • 5 commits — 5 feature/other, 0 fixes

By area

  • (repo) — 2 commits
  • app/actions — 1 commit
  • app/models — 1 commit
  • app/services — 1 commit

Notable commits

  • change: Describe memory options by how the computer feels, not how many runs fit
  • change: Let a credential's token be replaced, and refresh pull secrets on every project using it
  • change: Let each agent computer pick its memory, recommending 8Gi, and stop claiming a CPU shortfall of 4 cores
  • change: Merge pull request #785 from CanineHQ/agent-computer-memory
  • change: Merge pull request #786 from CanineHQ/chriszhu__update-provider-token

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

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

Survey your own repository

CanineHQ/canine 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 6 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 6bfa93d64e55ba28681190468914deb7fb272427 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — 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.2+preprod-5c4e66d9318b.