A modern, beautiful Kubernetes management desktop application with real-time monitoring, terminal access, and a polished user experience.

• Multi-Cluster Support - Connect to multiple clusters, auto-detect provider type (Minikube, EKS, GKE, AKS)
• Real-Time Updates - WebSocket-based pod watching with efficient Kubernetes watch API
• Resource Browser - View and manage Pods, Deployments, Services, ConfigMaps, Secrets, Nodes, and more
• Pod Logs - Stream logs in real-time with filtering, search, and export
• Terminal Access - Interactive shell access to running containers via XTerm.js
• Port Forwarding - Forward ports from pods/services to localhost with status tracking
• Metrics Dashboard - CPU and memory usage visualization (requires metrics-server)
• YAML Editor - Full Monaco editor integration for viewing and editing resources
• AI Assistant - Integrated AI support with Claude Code CLI and OpenAI Codex CLI
• MCP Server - Model Context Protocol server for IDE integration (VS Code, Cursor, Claude Code)
• Helm Releases - View and manage Helm deployments
• Proxy Support - HTTP/HTTPS/SOCKS5 proxy configuration for corporate environments
• Internationalization - English and German language support
• Dark/Light Mode - Theme support with vibrancy effects

Prerequisites:

• Node.js 18+
• Rust 1.70+
• npm (default) or pnpm

# Clone the repository
git clone https://github.com/atilladeniz/kubeli.git
cd kubeli

# Install dependencies
make install

# Run in development mode
make dev

# Build for production (macOS)
make build

# Build for Windows (cross-compile from macOS)
make install-windows-build-deps  # One-time setup
make build-windows

# Build both platforms
make build-all

# Start Tauri + Vite dev environment
make dev

# Start Vite only (no Tauri)
make web-dev

# Run linting
make lint

# Format code
make format

# Type check
make check

• make dev runs the live Tauri dev server with hot reload (uses the dev URL).
• make screenshot-build creates a bundled debug app (Kubeli.app) used for deep-link screenshot automation. This is not the same as dev mode.

For automated screenshots (deep links are debug-only):

# Build bundled debug app for screenshots
make screenshot-build

# Capture all screenshots
make screenshots

You can override the target context:

SCREENSHOT_CONTEXT="minikube (dev)" make screenshots

# Frontend unit tests
npm run test

# Backend unit tests
cd src-tauri && cargo test

# E2E smoke tests (static export + mocked IPC)
npm run test:e2e

npm run test:e2e loads environment defaults from config/e2e.env and injects a mocked Google Fonts response from config/font-mocks.cjs.

For testing Kubeli with simulated environments (OpenShift, EKS/GKE/AKS contexts, auth errors, scale testing), see the Local Testing Lab documentation. This allows you to test environment detection and error handling without cloud provider access.

# Quick examples
make minikube-setup-openshift    # OpenShift CRDs + Routes
make kubeconfig-fake-eks         # Fake EKS context
make minikube-setup-scale N=100  # Create 100 dummy pods

Kubeli provides CycloneDX SBOMs for supply chain security and compliance.

Every GitHub Release includes validated SBOMs as downloadable assets. The CI pipeline:

1. Generates SBOMs excluding dev/build dependencies
2. Validates against CycloneDX 1.5 schema
3. Attaches to release for audit/compliance download

# Generate both SBOMs
make sbom

# Generate and validate (requires Docker)
make sbom-validate

These SBOMs support:

• Vulnerability scanning (Grype, Trivy, Snyk)
• License compliance audits
• Supply chain security (SLSA, SSDF frameworks)
• Regulatory requirements (FDA, EU CRA, Executive Order 14028)

Kubeli includes automated security scanning in CI and local development.

Results appear in the GitHub Security tab (requires GitHub Advanced Security for private repos).

# Run all security scans (requires Docker)
make security-scan

# Individual scans
make security-trivy    # Vulnerability + secret scanning
make security-semgrep  # Static code analysis

• trivy.yaml - Severity thresholds and scan settings
• trivy-secret.yaml - Secret detection rules
• .semgrep.yaml - Custom SAST rules for TypeScript and Rust

Vet is an AI-powered code verification tool that reviews code changes for correctness, security issues, and goal adherence. It uses your existing Claude Code subscription (no extra API keys needed).

# Review all changes in current branch against main
# (auto-generates goal from commit messages if GOAL is omitted)
make vet

# Review with a specific goal
make vet GOAL="Refactor storage layer without breaking API"

1. Vet compares all commits in the current branch against main (full branch diff)
2. Sends the diff + your goal description to Claude (via Claude Code)
3. Returns a list of issues: logic errors, security problems, goal mismatches
4. Exit code 0 = no issues, 10 = issues found

make install will attempt to install vet automatically (requires Python with pipx, uv, or pip). If Python is not available, vet is skipped with a warning. To install separately:

make vet-install

Vet is also installed as a Claude Code skill (.claude/skills/vet/). When using Claude Code for development, the agent will proactively run vet after code changes to catch issues early.

• Requirements: macOS 10.15+ (Catalina or later)
• Architecture: Apple Silicon (arm64) native
• Auto-Updates: Fully supported via Tauri updater

• Requirements: Windows 10/11 (64-bit)
• WebView2: Automatically installed if missing (embedded bootstrapper)
• Auto-Updates: Fully supported via Tauri updater
• Note: First launch may show SmartScreen warning (app is not code-signed with Microsoft certificate)

• Requirements: x64 Linux with GLIBC 2.31+ (Ubuntu 20.04+, Fedora 33+, etc.)
• Format: AppImage (portable, no installation required)
• Auto-Updates: Fully supported via Tauri updater

For developing or testing Kubeli on Windows, see the Windows Setup Guide.

kubeli/
├── src/                    # React frontend (Vite)
│   ├── app/                # App styles/tests
│   ├── components/         # React components
│   │   ├── features/       # AI, Dashboard, Home, Logs, Port Forward, Resources,
│   │   │                   # Settings, Shortcuts, Terminal, Updater, Visualization
│   │   ├── layout/         # Sidebar, Tabbar, Titlebar
│   │   └── ui/             # Radix UI components
│   └── lib/
│       ├── hooks/          # useK8sResources, useLogs, useShell, etc.
│       ├── stores/         # Zustand stores
│       ├── tauri/          # Tauri command bindings
│       └── types/          # TypeScript definitions
├── src-tauri/              # Tauri/Rust backend
│   └── src/
│       ├── commands/       # clusters, resources, logs, shell, portforward,
│       │                   # flux, helm, metrics, mcp, network, watch, etc.
│       ├── k8s/            # KubeClientManager, config parsing
│       ├── ai/             # AI assistant integration
│       └── mcp/            # MCP server
├── web/                    # Landing page (Astro)
└── Makefile                # Development shortcuts

We welcome contributions! Please read our Contributing Guide and AI Usage Policy before submitting PRs.

See CHANGELOG.md for a detailed list of changes.

This project is licensed under the MIT License - see the LICENSE file for details.

Created by Atilla Deniz