web wasm ui

Split cli and gui bins
2025-08-22 06:27:15 +00:00 · 2025-07-24 08:34:53 +03:00 · 2025-07-24 08:24:51 +03:00 · 2025-07-24 05:10:41 +03:00 · 2025-07-24 05:01:04 +03:00 · 2025-07-24 04:50:08 +03:00
39 changed files with 9383 additions and 1126 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,33 @@
+# Git
+.git/
+.gitignore
+
+# Rust build artifacts
+target/
+Cargo.lock
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+*.md
+LICENSE
+
+# CI/CD
+.github/
+.gitlab-ci.yml
+
+# Testing
+tests/
+benches/
+
+# Development files
+*.log
+*.tmp
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -7,25 +7,37 @@ on:

 env:
  CARGO_TERM_COLOR: always
-  BINARY_NAME: khm
+  CLI_BINARY_NAME: khm
+  DESKTOP_BINARY_NAME: khm-desktop

 jobs:
  build:
    name: Build static binary
    runs-on: ${{ matrix.os }}
    strategy:
+      fail-fast: false
      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
        include:
+          # - os: ubuntu-latest
+          #   build_target: x86_64-unknown-linux-musl
+          #   platform_name: linux-amd64-musl
+          #   build_type: musl
          - os: ubuntu-latest
-            build_target: x86_64-unknown-linux-musl
+            build_target: x86_64-unknown-linux-gnu
            platform_name: linux-amd64
+            build_type: dynamic
+          - os: ubuntu-latest
+            build_target: aarch64-unknown-linux-gnu
+            platform_name: linux-arm64
+            build_type: dynamic  # CLI only - GUI deps too complex for cross-compilation
          - os: windows-latest
            build_target: x86_64-pc-windows-msvc
            platform_name: windows-amd64
+            build_type: default
          - os: macos-latest
            build_target: aarch64-apple-darwin
            platform_name: macos-arm64
+            build_type: default
    permissions:
      contents: write
    steps:
@@ -60,79 +72,149 @@ jobs:
      - name: Install rust targets
        run: rustup target add ${{ matrix.build_target }}
        
-      - name: Build Linux MUSL
-        if: matrix.os == 'ubuntu-latest'
-        uses: gmiam/rust-musl-action@master
-        with:
-          args: cargo build --target ${{ matrix.build_target }} --release
+      - name: Install Linux x86_64 dependencies
+        if: matrix.os == 'ubuntu-latest' && matrix.build_type == 'dynamic' && matrix.build_target == 'x86_64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libssl-dev pkg-config libgtk-3-dev libglib2.0-dev libcairo2-dev libpango1.0-dev libatk1.0-dev libgdk-pixbuf2.0-dev libxdo-dev libayatana-appindicator3-dev
+          
+      - name: Install Linux ARM64 cross-compilation dependencies
+        if: matrix.os == 'ubuntu-latest' && matrix.build_type == 'dynamic' && matrix.build_target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          # Install cross-compilation tools and build dependencies for vendored OpenSSL
+          sudo apt-get install -y gcc-aarch64-linux-gnu pkg-config libssl-dev build-essential make perl
+          
+      - name: Build Linux x86_64
+        if: matrix.os == 'ubuntu-latest' && matrix.build_type == 'dynamic' && matrix.build_target == 'x86_64-unknown-linux-gnu'
+        run: |
+          # Build CLI without GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm --no-default-features --features cli
+          # Build Desktop with GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm-desktop
+        
+      - name: Build Linux ARM64 (CLI only)
+        if: matrix.os == 'ubuntu-latest' && matrix.build_type == 'dynamic' && matrix.build_target == 'aarch64-unknown-linux-gnu'
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+          CC_aarch64_unknown_linux_gnu: aarch64-linux-gnu-gcc
+          CXX_aarch64_unknown_linux_gnu: aarch64-linux-gnu-g++
+        run: cargo build --target ${{ matrix.build_target }} --release --bin khm --no-default-features --features cli
+        
+      # - name: Build Linux MUSL (no GUI)
+      #   if: matrix.os == 'ubuntu-latest' && matrix.build_type == 'musl'
+      #   uses: gmiam/rust-musl-action@master
+      #   with:
+      #     args: |
+      #       sed -i 's/deb.debian.org/archive.debian.org/g' /etc/apt/sources.list
+      #       sed -i 's/security.debian.org/archive.debian.org/g' /etc/apt/sources.list
+      #       sed -i '/buster-updates/d' /etc/apt/sources.list
+      #       apt-get update && apt-get install -y pkg-config
+      #       cargo build --target ${{ matrix.build_target }} --release --no-default-features --features server
          
      - name: Build MacOS
        if: matrix.os == 'macos-latest'
-        run: cargo build --target ${{ matrix.build_target }} --release
+        run: |
+          # Build CLI without GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm --no-default-features --features cli
+          # Build Desktop with GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm-desktop
          
      - name: Build Windows
        if: matrix.os == 'windows-latest'
-        run: cargo build --target ${{ matrix.build_target }} --release
+        run: |
+          # Build CLI without GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm --no-default-features --features cli
+          # Build Desktop with GUI features
+          cargo build --target ${{ matrix.build_target }} --release --bin khm-desktop
          
-      - name: Upload artifact
+      - name: Upload CLI artifact
        uses: actions/upload-artifact@v4
        with:
-          name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          path: target/${{ matrix.build_target }}/release/${{ env.BINARY_NAME }}*
+          name: ${{ env.CLI_BINARY_NAME }}_${{ matrix.platform_name }}
+          path: |
+            target/${{ matrix.build_target }}/release/${{ env.CLI_BINARY_NAME }}${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+            
+      - name: Upload Desktop artifact
+        # Only upload desktop binary for x86_64 platforms (not ARM64)
+        if: matrix.build_target != 'aarch64-unknown-linux-gnu'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.DESKTOP_BINARY_NAME }}_${{ matrix.platform_name }}
+          path: |
+            target/${{ matrix.build_target }}/release/${{ env.DESKTOP_BINARY_NAME }}${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+        continue-on-error: true  # Don't fail if desktop binary doesn't build on some platforms

  release:
-    name: Create Release Page
+    name: Create Release and Upload Assets
+    if: always()  # Always run even if some builds fail
    needs: build
    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
+          path: artifacts/
+      
+      - name: Prepare release assets
+        run: |
+          mkdir -p release-assets/
+          # Copy files with proper naming from each artifact directory
+          for artifact_dir in artifacts/*/; do
+            if [[ -d "$artifact_dir" ]]; then
+              artifact_name=$(basename "$artifact_dir")
+              echo "Processing artifact: $artifact_name"
+              
+              # Extract binary type and platform from artifact name
+              if [[ "$artifact_name" =~ ^khm-desktop_(.*)$ ]]; then
+                binary_type="desktop"
+                platform="${BASH_REMATCH[1]}"
+                binary_name="${{ env.DESKTOP_BINARY_NAME }}"
+              elif [[ "$artifact_name" =~ ^khm_(.*)$ ]]; then
+                binary_type="cli"
+                platform="${BASH_REMATCH[1]}"
+                binary_name="${{ env.CLI_BINARY_NAME }}"
+              else
+                echo "Unknown artifact format: $artifact_name"
+                continue
+              fi
+              
+              echo "Binary type: $binary_type, Platform: $platform, Binary name: $binary_name"
+              
+              # For Windows, look for .exe file specifically
+              if [[ "$platform" == "windows-amd64" ]]; then
+                exe_file=$(find "$artifact_dir" -name "${binary_name}.exe" -type f | head -1)
+                if [[ -n "$exe_file" ]]; then
+                  cp "$exe_file" "release-assets/${binary_name}_${platform}.exe"
+                  echo "Copied: $exe_file -> release-assets/${binary_name}_${platform}.exe"
+                fi
+              else
+                # For Linux/macOS, look for binary without extension
+                binary_file=$(find "$artifact_dir" -name "${binary_name}" -type f | head -1)
+                if [[ -n "$binary_file" ]]; then
+                  cp "$binary_file" "release-assets/${binary_name}_${platform}"
+                  echo "Copied: $binary_file -> release-assets/${binary_name}_${platform}"
+                fi
+              fi
+            fi
+          done
+          
+          echo "Final release assets:"
+          ls -la release-assets/
+      
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: Release ${{ github.ref_name }}
+          files: release-assets/*
          draft: false
          prerelease: false
-
-  upload:
-    name: Upload Release Assets
-    needs: release
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - os: ubuntu-latest
-            platform_name: linux-amd64
-          - os: windows-latest
-            platform_name: windows-amd64
-          - os: macos-latest
-            platform_name: macos-arm64
-    steps:
-      - uses: actions/checkout@v4
-      
-      - uses: actions/download-artifact@v4
-        name: Download ${{ matrix.platform_name }} artifact
-        with:
-          name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          path: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          
-      - name: Upload Release Asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.release.outputs.upload_url }}
-          asset_path: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}/${{ env.BINARY_NAME }}${{ matrix.platform_name == 'windows-amd64' && '.exe' || '' }}
-          asset_name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}${{ matrix.platform_name == 'windows-amd64' && '.exe' || '' }}
-          asset_content_type: application/octet-stream
+          generate_release_notes: true
+          fail_on_unmatched_files: false

  build_docker:
    name: Build and Publish Docker Image
@@ -141,15 +223,26 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      
-      - uses: actions/download-artifact@v4
-        name: Download Linux artifact
+      - name: Download Linux AMD64 CLI artifact
+        uses: actions/download-artifact@v4
        with:
-          name: ${{ env.BINARY_NAME }}_linux-amd64
-          path: .
+          name: ${{ env.CLI_BINARY_NAME }}_linux-amd64
+          path: amd64/
          
-      - name: ls
+      - name: Download Linux ARM64 CLI artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ env.CLI_BINARY_NAME }}_linux-arm64
+          path: arm64/
+          
+      - name: Prepare binaries for multi-arch build
        run: |
-          ls -lah
+          mkdir -p bin/linux_amd64 bin/linux_arm64
+          cp amd64/${{ env.CLI_BINARY_NAME }} bin/linux_amd64/${{ env.CLI_BINARY_NAME }}
+          cp arm64/${{ env.CLI_BINARY_NAME }} bin/linux_arm64/${{ env.CLI_BINARY_NAME }}
+          chmod +x bin/linux_amd64/${{ env.CLI_BINARY_NAME }}
+          chmod +x bin/linux_arm64/${{ env.CLI_BINARY_NAME }}
+          ls -la bin/*/
          
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
@@ -163,10 +256,6 @@ jobs:
          username: ultradesu
          password: ${{ secrets.DOCKERHUB_TOKEN }}
          
-      - name: Set exec flag
-        run: |
-          chmod +x ${{ env.BINARY_NAME }}
-          
      - name: Set outputs
        id: get_tag
        run: |
@@ -178,5 +267,5 @@ jobs:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
-          tags: ultradesu/${{ env.BINARY_NAME }}:latest,ultradesu/${{ env.BINARY_NAME }}:${{ steps.get_tag.outputs.tag }}
+          tags: ultradesu/${{ env.CLI_BINARY_NAME }}:latest,ultradesu/${{ env.CLI_BINARY_NAME }}:${{ steps.get_tag.outputs.tag }}

--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 /target
 *.swp
 *.swo
+.claude/
+khm-wasm/target
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1002,6 +1002,7 @@ dependencies = [
 "iana-time-zone",
 "js-sys",
 "num-traits",
+ "serde",
 "wasm-bindgen",
 "windows-targets 0.52.6",
 ]
@@ -1121,6 +1122,16 @@ dependencies = [
 "crossbeam-utils",
 ]

+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.4.0"
@@ -1935,8 +1946,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
 "cfg-if",
+ "js-sys",
 "libc",
 "wasi",
+ "wasm-bindgen",
 ]

 [[package]]
@@ -2672,21 +2685,26 @@ dependencies = [

 [[package]]
 name = "khm"
-version = "0.6.3"
+version = "0.7.1"
 dependencies = [
 "actix-web",
 "base64 0.21.7",
 "chrono",
 "clap",
+ "console_error_panic_hook",
 "dirs 5.0.1",
 "eframe",
 "egui",
 "env_logger",
 "futures",
+ "getrandom",
+ "glib",
+ "gtk",
 "hostname",
 "log",
 "notify",
 "notify-debouncer-mini",
+ "openssl",
 "regex",
 "reqwest",
 "rust-embed",
@@ -2695,9 +2713,13 @@ dependencies = [
 "tokio",
 "tokio-postgres",
 "tokio-util",
+ "tracing-wasm",
 "tray-icon",
 "trust-dns-resolver",
 "urlencoding",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 "winit",
 ]

@@ -2744,6 +2766,12 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4345964bb142484797b161f473a503a434de77149dd8c7427788c6e13379388"

+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libappindicator"
 version = "0.9.0"
@@ -2993,21 +3021,22 @@ dependencies = [

 [[package]]
 name = "muda"
-version = "0.15.3"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdae9c00e61cc0579bcac625e8ad22104c60548a025bfc972dc83868a28e1484"
+checksum = "58b89bf91c19bf036347f1ab85a81c560f08c0667c8601bece664d860a600988"
 dependencies = [
 "crossbeam-channel",
 "dpi",
 "gtk",
 "keyboard-types",
 "libxdo",
- "objc2 0.5.2",
- "objc2-app-kit 0.2.2",
- "objc2-foundation 0.2.2",
+ "objc2 0.6.1",
+ "objc2-app-kit 0.3.1",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.1",
 "once_cell",
 "png",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
 "windows-sys 0.59.0",
 ]

@@ -3512,6 +3541,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"

+[[package]]
+name = "openssl-src"
+version = "300.5.1+3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "735230c832b28c000e3bc117119e6466a663ec73506bc0a9907ea4187508e42a"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.102"
@@ -3520,6 +3558,7 @@ checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
 dependencies = [
 "cc",
 "libc",
+ "openssl-src",
 "pkg-config",
 "vcpkg",
 ]
@@ -4338,6 +4377,15 @@ dependencies = [
 "digest",
 ]

+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.2"
@@ -4617,6 +4665,15 @@ dependencies = [
 "syn 2.0.87",
 ]

+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "time"
 version = "0.3.36"
@@ -4894,10 +4951,32 @@ dependencies = [
 ]

 [[package]]
-name = "tray-icon"
-version = "0.19.3"
+name = "tracing-subscriber"
+version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadd75f5002e2513eaa19b2365f533090cc3e93abd38788452d9ea85cff7b48a"
+checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+dependencies = [
+ "sharded-slab",
+ "thread_local",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2da75ec677957aa21f6e0b361df0daab972f13a5bee3606de0638fd4ee1c666a"
 dependencies = [
 "crossbeam-channel",
 "dirs 6.0.0",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "khm"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 authors = ["AB <ab@hexor.cy>"]
 description = "KHM - Known Hosts Manager for SSH key management and synchronization"
@@ -10,35 +10,71 @@ license = "WTFPL"
 keywords = ["ssh", "known-hosts", "security", "system-admin", "automation"]
 categories = ["command-line-utilities", "network-programming"]

+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[[bin]]
+name = "khm"
+path = "src/bin/cli.rs"
+
+[[bin]]
+name = "khm-desktop"
+path = "src/bin/desktop.rs"
+required-features = ["gui"]
+
 [dependencies]
-actix-web = "4"
+actix-web = { version = "4", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 log = "0.4"
-regex = "1.10.5"
-base64 = "0.21"
-tokio = { version = "1", features = ["full", "sync"] }
-tokio-postgres = { version = "0.7", features = ["with-chrono-0_4"] }
-tokio-util = { version = "0.7", features = ["codec"] }
-clap = { version = "4", features = ["derive"] }
-chrono = "0.4.38"
-reqwest = { version = "0.12", features = ["json"] }
-trust-dns-resolver = "0.23"
-futures = "0.3"
-hostname = "0.3"
-rust-embed = "8.0"
-tray-icon = { version = "0.19", optional = true }
+regex = { version = "1.10.5", optional = true }
+base64 = { version = "0.21", optional = true }
+tokio = { version = "1", features = ["full", "sync"], optional = true }
+tokio-postgres = { version = "0.7", features = ["with-chrono-0_4"], optional = true }
+tokio-util = { version = "0.7", features = ["codec"], optional = true }
+clap = { version = "4", features = ["derive"], optional = true }
+chrono = { version = "0.4.38", features = ["serde"], optional = true }
+reqwest = { version = "0.12", features = ["json"], optional = true }
+trust-dns-resolver = { version = "0.23", optional = true }
+futures = { version = "0.3", optional = true }
+hostname = { version = "0.3", optional = true }
+rust-embed = { version = "8.0", optional = true }
+tray-icon = { version = "0.21", optional = true }
 notify = { version = "6.1", optional = true }
 notify-debouncer-mini = { version = "0.4", optional = true }
 dirs = "5.0"
 eframe = { version = "0.29", optional = true }
 egui = { version = "0.29", optional = true }
+wasm-bindgen-futures = { version = "0.4", optional = true }
+web-sys = { version = "0.3", optional = true }
+wasm-bindgen = { version = "0.2", optional = true }
+console_error_panic_hook = { version = "0.1", optional = true }
+tracing-wasm = { version = "0.2", optional = true }
+getrandom = { version = "0.2", features = ["js"], optional = true }
 winit = { version = "0.30", optional = true }
 env_logger = "0.11"
 urlencoding = "2.1"

-[features]
-default = ["gui"]
-gui = ["tray-icon", "eframe", "egui", "winit", "notify", "notify-debouncer-mini"]
-server = []
+# Linux-specific dependencies for GTK tray support
+[target.'cfg(target_os = "linux")'.dependencies]
+gtk = { version = "0.18", optional = true }
+glib = { version = "0.18", optional = true }
+
+[features]
+default = ["server", "web", "gui"]
+cli = ["server", "web", "web-gui"]
+desktop = ["gui"]
+gui = ["tray-icon", "eframe", "egui", "winit", "notify", "notify-debouncer-mini", "gtk", "glib"]
+web-gui = ["egui", "eframe", "wasm-bindgen-futures", "web-sys", "wasm-bindgen", "console_error_panic_hook", "tracing-wasm", "getrandom"]
+web-gui-wasm = ["web-gui"]
+server = ["actix-web", "tokio", "tokio-postgres", "tokio-util", "clap", "chrono", "regex", "base64", "futures", "hostname", "rust-embed", "trust-dns-resolver", "reqwest"]
+web = ["server"]
+
+# Target-specific dependencies for cross-compilation
+[target.aarch64-unknown-linux-gnu.dependencies]
+openssl = { version = "0.10", features = ["vendored"] }
+
+# WASM-specific dependencies
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = ["js"] }

--- a/18
+++ b/18
@@ -1,5 +1,19 @@
 # syntax=docker/dockerfile:1

-FROM alpine:latest
-COPY khm /usr/local/bin/khm
+FROM debian:12-slim
+
+# Install only essential runtime dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the CLI binary (without GUI dependencies)
+ARG TARGETARCH
+COPY bin/linux_${TARGETARCH}/khm /usr/local/bin/khm
+RUN chmod +x /usr/local/bin/khm
+
+# Create non-root user
+RUN useradd -m -u 1000 khm
+USER khm
+
 ENTRYPOINT ["/usr/local/bin/khm"]
--- a/README.MD
+++ b/README.MD
@@ -1,65 +1,166 @@
 # KHM - Known Hosts Manager

-KHM allows you to synchronize the `known_hosts` file across multiple hosts. This application manages SSH keys and flows, either as a server or client. In server mode, it stores keys and flows in a PostgreSQL database. In client mode, it sends keys to the server and can update the `known_hosts` file with keys from the server.
+KHM is a comprehensive SSH key management tool that allows you to synchronize `known_hosts` files across multiple hosts and environments. The application supports multiple operation modes: server mode for centralized key storage, client mode for synchronization, and GUI mode for easy management.

 ## Features

- Synchronize `known_hosts` file across multiple hosts.
- Manage SSH keys and flows in a PostgreSQL database.
- Operate in both server and client modes.
- Automatically update `known_hosts` file with keys from the server.
+- **Multi-mode operation**: Server, client, and GUI modes
+- **Centralized key management**: Store SSH keys and flows in PostgreSQL database
+- **Cross-platform GUI**: Modern tray application with settings window
+- **Automatic synchronization**: Keep `known_hosts` files updated across environments
+- **Flow-based organization**: Manage different environments (production, staging, development)
+- **Authentication support**: Basic authentication for secure API access
+- **Real-time monitoring**: Auto-sync capabilities with configurable intervals

-## Usage
+## Operation Modes

 ### Server Mode
-
-To run the application in server mode, use the following command:
+Runs a web server that stores and manages SSH keys in a PostgreSQL database.

 ```bash
-khm --server --ip 127.0.0.1 --port 8080 --db-host 127.0.0.1 --db-name khm --db-user admin --db-password <SECRET> --flows work,home
+khm --server --ip 0.0.0.0 --port 1337 --db-host psql.psql.svc --db-name khm --db-user admin --db-password <SECRET> --flows work,home
 ```

 ### Client Mode
-
-To run the application in client mode, use the following command:
+Connects to a KHM server to send local keys and optionally sync the `known_hosts` file.

 ```bash
-khm --host http://khm.example.com:8080/<FLOW_NAME>/ --known-hosts ~/.ssh/known_hosts --in-place
+khm --host https://khm.example.com --flow work --known-hosts ~/.ssh/known_hosts --in-place
 ```

-### Arguments
-Options:
- `--server` Run in server mode
- `--in-place` Server mode: Sync the known_hosts file with keys from the server
- `--flows <FLOWS>...` Server mode: Comma-separated list of flows to manage [default: default]
- `-i, --ip <IP>` Server mode: IP address to bind the server to [default: 127.0.0.1]
- `-p, --port <PORT>` Server mode: Port to bind the server to [default: 8080]
- `--db-host <DB_HOST>` Server mode: Hostname or IP address of the PostgreSQL database [default: 127.0.0.1]
- `--db-name <DB_NAME>` Server mode: Name of the PostgreSQL database [default: khm]
- `--db-user <DB_USER>` Server mode: Username for the PostgreSQL database
- `--db-password <DB_PASSWORD>` Server mode: Password for the PostgreSQL database
- `--basic-auth <BASIC_AUTH>` Client mode: Basic Auth credentials [default: ""]
- `--host <HOST>` Client mode: Full host address of the server to connect to. Like `https://khm.example.com/<FLOW_NAME>`
- `--known-hosts <KNOWN_HOSTS>` Client mode: Path to the known_hosts file [default: ~/.ssh/known_hosts]
+### GUI Mode
+Launches a system tray application with a modern interface for easy management.

+```bash
+# Run tray application
+khm --gui
+
+# Run settings window only
+khm --settings-ui
+```
+
+## Command Line Arguments
+
+### General Options
+- `--server` - Run in server mode
+- `--gui` - Run with GUI tray interface
+- `--settings-ui` - Run settings UI window (used with --gui)
+
+### Server Mode Options
+- `-i, --ip <IP>` - IP address to bind the server to [default: 127.0.0.1]
+- `-p, --port <PORT>` - Port to bind the server to [default: 8080]
+- `--flows <FLOWS>` - Comma-separated list of flows to manage [default: default]
+- `--db-host <DB_HOST>` - PostgreSQL database hostname [default: 127.0.0.1]
+- `--db-name <DB_NAME>` - PostgreSQL database name [default: khm]
+- `--db-user <DB_USER>` - PostgreSQL database username (required)
+- `--db-password <DB_PASSWORD>` - PostgreSQL database password (required)
+
+### Client Mode Options
+- `--host <HOST>` - Server URL (e.g., https://khm.example.com) (required)
+- `--flow <FLOW>` - Flow name to use on the server (required)
+- `--known-hosts <PATH>` - Path to known_hosts file [default: ~/.ssh/known_hosts]
+- `--in-place` - Update known_hosts file with server keys after sync
+- `--basic-auth <CREDENTIALS>` - Basic authentication (format: user:pass)
+
+## GUI Features
+
+The GUI mode provides:
+
+- **System Tray Integration**: Runs quietly in the system tray
+- **Settings Management**: Easy configuration through modern UI
+- **Connection Testing**: Built-in server connectivity testing
+- **Manual Synchronization**: On-demand sync operations
+- **Auto-sync Configuration**: Configurable automatic synchronization intervals
+- **Operation Logging**: Real-time activity monitoring
+- **Cross-platform Paths**: Automatic path handling for different operating systems

 ## Installation

-1. Ensure you have Rust installed. If not, you can install it from [rustup.rs](https://rustup.rs/).
+### From Binary Releases
+Download the latest binary from the [Releases](https://github.com/house-of-vanity/khm/releases) page.
+
+### From Source
+1. Install Rust from [rustup.rs](https://rustup.rs/)
 2. Clone the repository:
-    ```bash
-    git clone https://github.com/house-of-vanity/khm.git
-    cd khm
-    ```
-3. Run the project:
-    ```bash
-    cargo run --release -- --help
-    ```
+   ```bash
+   git clone https://github.com/house-of-vanity/khm.git
+   cd khm
+   ```
+3. Build and run:
+   ```bash
+   # Build both binaries (CLI without GUI, Desktop with GUI)
+   cargo build --release --bin khm --no-default-features --features cli
+   cargo build --release --bin khm-desktop
+   
+   # Or build all at once with default features
+   cargo build --release
+   ```
+
+### System Dependencies
+For GUI features on Linux:
+```bash
+# Build dependencies
+sudo apt-get install libgtk-3-dev libglib2.0-dev libcairo2-dev libpango1.0-dev libatk1.0-dev libgdk-pixbuf2.0-dev
+```
+
+## Configuration
+
+### GUI Configuration
+Settings are automatically saved to:
+- **Windows**: `%USERPROFILE%\.khm\khm_config.json`
+- **macOS**: `~/.khm/khm_config.json`
+- **Linux**: `~/.khm/khm_config.json`
+
+### Example Configuration
+```json
+{
+  "host": "https://khm.example.com",
+  "flow": "production",
+  "known_hosts": "/home/user/.ssh/known_hosts",
+  "basic_auth": "",
+  "in_place": true,
+  "auto_sync_interval_minutes": 60
+}
+```
+
+## Examples
+
+### Complete Server Setup
+```bash
+# Start server with multiple flows
+khm --server \
+    --ip 0.0.0.0 \
+    --port 8080 \
+    --db-host localhost \
+    --db-name khm \
+    --db-user khm_user \
+    --db-password secure_password \
+    --flows production,staging,development
+```
+
+### Client Synchronization
+```bash
+# Send keys and update local known_hosts
+khm --host https://khm.company.com \
+    --flow production \
+    --known-hosts ~/.ssh/known_hosts \
+    --in-place \
+    --basic-auth "username:password"
+```
+
+### GUI Usage
+```bash
+# Launch tray application
+khm --gui
+
+# Open settings window directly
+khm --settings-ui
+```

 ## Contributing

-Contributions are welcome! Please open an issue or submit a pull request for any changes.
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.

 ## License

-This project is licensed under the WTFPL License.
+This project is licensed under the WTFPL License - see the [LICENSE](LICENSE) file for details.
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,34 @@
+version: '3.8'
+
+services:
+  khm:
+    image: ultradesu/khm:latest
+    restart: unless-stopped
+    environment:
+      # Server mode configuration
+      - KHM_SERVER=true
+      - KHM_IP=0.0.0.0
+      - KHM_PORT=8080
+      - KHM_DB_HOST=postgres
+      - KHM_DB_NAME=khm
+      - KHM_DB_USER=khm
+      - KHM_DB_PASSWORD=changeme
+      - KHM_FLOWS=prod,staging,dev
+    ports:
+      - "8080:8080"
+    depends_on:
+      - postgres
+    command: ["--server", "--ip", "0.0.0.0", "--port", "8080", "--db-host", "postgres", "--db-name", "khm", "--db-user", "khm", "--db-password", "changeme", "--flows", "prod,staging,dev"]
+
+  postgres:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    environment:
+      - POSTGRES_USER=khm
+      - POSTGRES_PASSWORD=changeme
+      - POSTGRES_DB=khm
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
--- a/khm-wasm/Cargo.lock
+++ b/khm-wasm/Cargo.lock
--- a/khm-wasm/Cargo.toml
+++ b/khm-wasm/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "khm-wasm"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+log = "0.4"
+eframe = { version = "0.29", default-features = false, features = ["glow"] }
+egui = "0.29"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = ["console", "Headers", "Request", "RequestInit", "RequestMode", "Response", "Window"] }
+console_error_panic_hook = "0.1"
+tracing-wasm = "0.2"
+getrandom = { version = "0.2", features = ["js"] }
+serde-wasm-bindgen = "0.6"
+
+[features]
+default = []
--- a/khm-wasm/src/lib.rs
+++ b/khm-wasm/src/lib.rs
--- a/src/bin/cli.rs
+++ b/src/bin/cli.rs
@@ -1,21 +1,16 @@
-mod client;
-mod db;
-mod server;
-mod web;
-mod gui;
+use khm::{client, server, Args};

 use clap::Parser;
 use env_logger;
 use log::{error, info};

-/// This application manages SSH keys and flows, either as a server or client.
-/// In server mode, it stores keys and flows in a PostgreSQL database.
-/// In client mode, it sends keys to the server and can update the known_hosts file with keys from the server.
+/// CLI version of KHM - Known Hosts Manager for SSH key management and synchronization
+/// Supports server and client modes without GUI dependencies
 #[derive(Parser, Debug, Clone)]
 #[command(
    author = env!("CARGO_PKG_AUTHORS"),
    version = env!("CARGO_PKG_VERSION"),
-    about = "SSH Host Key Manager",
+    about = "SSH Host Key Manager (CLI with Server)",
    long_about = None,
    after_help = "Examples:\n\
    \n\
@@ -27,19 +22,11 @@ use log::{error, info};
    \n\
    "
 )]
-pub struct Args {
+pub struct CliArgs {
    /// Run in server mode (default: false)
    #[arg(long, help = "Run in server mode")]
    pub server: bool,

-    /// Run with GUI tray interface (default: false)
-    #[arg(long, help = "Run with GUI tray interface")]
-    pub gui: bool,
-
-    /// Run settings UI window (used with --gui)
-    #[arg(long, help = "Run settings UI window (used with --gui)")]
-    pub settings_ui: bool,
-
    /// Update the known_hosts file with keys from the server after sending keys (default: false)
    #[arg(
        long,
@@ -130,6 +117,28 @@ pub struct Args {
    pub basic_auth: String,
 }

+impl From<CliArgs> for Args {
+    fn from(cli_args: CliArgs) -> Self {
+        Args {
+            server: cli_args.server,
+            daemon: false,
+            settings_ui: false,
+            in_place: cli_args.in_place,
+            flows: cli_args.flows,
+            ip: cli_args.ip,
+            port: cli_args.port,
+            db_host: cli_args.db_host,
+            db_name: cli_args.db_name,
+            db_user: cli_args.db_user,
+            db_password: cli_args.db_password,
+            host: cli_args.host,
+            flow: cli_args.flow,
+            known_hosts: cli_args.known_hosts,
+            basic_auth: cli_args.basic_auth,
+        }
+    }
+}
+
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
    // Configure logging to show only khm logs, filtering out noisy library logs
@@ -138,72 +147,20 @@ async fn main() -> std::io::Result<()> {
        .filter_module("khm", log::LevelFilter::Debug) // Our app logs
        .filter_module("actix_web", log::LevelFilter::Info) // Server logs
        .filter_module("reqwest", log::LevelFilter::Warn) // HTTP client
-        .filter_module("winit", log::LevelFilter::Error) // Window management
-        .filter_module("egui", log::LevelFilter::Error) // GUI framework
-        .filter_module("eframe", log::LevelFilter::Error) // GUI framework
-        .filter_module("tray_icon", log::LevelFilter::Error) // Tray icon
-        .filter_module("wgpu", log::LevelFilter::Error) // Graphics
-        .filter_module("naga", log::LevelFilter::Error) // Graphics
-        .filter_module("glow", log::LevelFilter::Error) // Graphics
-        .filter_module("tracing", log::LevelFilter::Error) // Tracing spans
        .init();

-    info!("Starting SSH Key Manager");
+    info!("Starting SSH Key Manager (CLI)");

-    let args = Args::parse();
+    let cli_args = CliArgs::parse();
+    let args: Args = cli_args.into();

-    // Settings UI mode - just show settings window and exit
-    if args.settings_ui {
-        #[cfg(feature = "gui")]
-        {
-            info!("Running settings UI window");
-            gui::run_settings_window();
-            return Ok(());
-        }
-        #[cfg(not(feature = "gui"))]
-        {
-            error!("GUI features not compiled. Install system dependencies and rebuild with --features gui");
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Unsupported,
-                "GUI features not compiled"
-            ));
-        }
-    }
-
-    // GUI mode has priority
-    if args.gui {
-        info!("Running in GUI mode");
-        if let Err(e) = gui::run_gui().await {
-            error!("Failed to run GUI: {}", e);
-        }
-        return Ok(());
-    }
-
-    // Check if we have the minimum required arguments for server/client mode
-    if !args.server && !args.gui && (args.host.is_none() || args.flow.is_none()) {
-        // Neither server mode nor client mode nor GUI mode properly configured
-        eprintln!("Error: You must specify either server mode (--server), client mode (--host and --flow), or GUI mode (--gui)");
-        eprintln!();
-        eprintln!("Examples:");
-        eprintln!(
-            "  Server mode: {} --server --db-user admin --db-password pass --flows work,home",
-            env!("CARGO_PKG_NAME")
-        );
-        eprintln!(
-            "  Client mode: {} --host https://khm.example.com --flow work",
-            env!("CARGO_PKG_NAME")
-        );
-        eprintln!(
-            "  GUI mode: {} --gui",
-            env!("CARGO_PKG_NAME")
-        );
-        eprintln!(
-            "  Settings window: {} --gui --settings-ui",
-            env!("CARGO_PKG_NAME")
-        );
-        eprintln!();
-        eprintln!("Use --help for more information.");
-        std::process::exit(1);
+    // Validate arguments - either server mode or client mode with required args
+    if !args.server && (args.host.is_none() || args.flow.is_none()) {
+        error!("CLI version requires either --server mode or client mode with --host and --flow arguments");
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            "Invalid arguments for CLI mode",
+        ));
    }

    if args.server {
--- a/src/bin/desktop.rs
+++ b/src/bin/desktop.rs
@@ -0,0 +1,142 @@
+use khm::{gui, Args};
+
+use clap::Parser;
+use env_logger;
+use log::{error, info};
+
+/// Desktop version of KHM - Known Hosts Manager with GUI interface
+/// Primarily runs in GUI mode with tray application and settings windows
+#[derive(Parser, Debug, Clone)]
+#[command(
+    author = env!("CARGO_PKG_AUTHORS"),
+    version = env!("CARGO_PKG_VERSION"),
+    about = "SSH Host Key Manager (Desktop)",
+    long_about = None,
+    after_help = "Examples:\n\
+    \n\
+    Running in GUI tray mode (default):\n\
+    khm-desktop\n\
+    \n\
+    Running in GUI tray mode with background daemon:\n\
+    khm-desktop --daemon\n\
+    \n\
+    Running settings window:\n\
+    khm-desktop --settings-ui\n\
+    \n\
+    "
+)]
+pub struct DesktopArgs {
+    /// Hide console window and run in background (default: auto when no arguments)
+    #[arg(long, help = "Hide console window and run in background")]
+    pub daemon: bool,
+
+    /// Run settings UI window
+    #[arg(long, help = "Run settings UI window")]
+    pub settings_ui: bool,
+}
+
+impl From<DesktopArgs> for Args {
+    fn from(desktop_args: DesktopArgs) -> Self {
+        Args {
+            server: false,
+            daemon: desktop_args.daemon,
+            settings_ui: desktop_args.settings_ui,
+            in_place: false,
+            flows: vec!["default".to_string()],
+            ip: "127.0.0.1".to_string(),
+            port: 8080,
+            db_host: "127.0.0.1".to_string(),
+            db_name: "khm".to_string(),
+            db_user: None,
+            db_password: None,
+            host: None,
+            flow: None,
+            known_hosts: "~/.ssh/known_hosts".to_string(),
+            basic_auth: String::new(),
+        }
+    }
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    // Configure logging to show only khm logs, filtering out noisy library logs
+    env_logger::Builder::from_default_env()
+        .filter_level(log::LevelFilter::Warn) // Default level for all modules
+        .filter_module("khm", log::LevelFilter::Debug) // Our app logs
+        .filter_module("winit", log::LevelFilter::Error) // Window management
+        .filter_module("egui", log::LevelFilter::Error) // GUI framework
+        .filter_module("eframe", log::LevelFilter::Error) // GUI framework
+        .filter_module("tray_icon", log::LevelFilter::Error) // Tray icon
+        .filter_module("wgpu", log::LevelFilter::Error) // Graphics
+        .filter_module("naga", log::LevelFilter::Error) // Graphics
+        .filter_module("glow", log::LevelFilter::Error) // Graphics
+        .filter_module("tracing", log::LevelFilter::Error) // Tracing spans
+        .init();
+
+    info!("Starting SSH Key Manager (Desktop)");
+
+    let desktop_args = DesktopArgs::parse();
+    let args: Args = desktop_args.into();
+
+    // Hide console on Windows if daemon flag is set
+    if args.daemon {
+        #[cfg(target_os = "windows")]
+        {
+            extern "system" {
+                fn FreeConsole() -> i32;
+            }
+            unsafe {
+                FreeConsole();
+            }
+        }
+    }
+
+    // Settings UI mode - just show settings window and exit
+    if args.settings_ui {
+        // Always hide console for settings window
+        #[cfg(target_os = "windows")]
+        {
+            extern "system" {
+                fn FreeConsole() -> i32;
+            }
+            unsafe {
+                FreeConsole();
+            }
+        }
+        
+        #[cfg(feature = "gui")]
+        {
+            info!("Running settings UI window");
+            gui::run_settings_window();
+            return Ok(());
+        }
+        #[cfg(not(feature = "gui"))]
+        {
+            error!("GUI features not compiled. Install system dependencies and rebuild with --features gui");
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Unsupported,
+                "GUI features not compiled",
+            ));
+        }
+    }
+
+    // Default to GUI mode for desktop version
+    info!("Running in GUI mode");
+    #[cfg(feature = "gui")]
+    {
+        if let Err(e) = gui::run_gui().await {
+            error!("Failed to run GUI: {}", e);
+        }
+    }
+    #[cfg(not(feature = "gui"))]
+    {
+        error!("GUI features not compiled. Install system dependencies and rebuild with --features gui");
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::Unsupported,
+            "GUI features not compiled",
+        ));
+    }
+
+    info!("Application has exited");
+    Ok(())
+}
--- a/src/db.rs
+++ b/src/db.rs
@@ -493,7 +493,9 @@ impl DbClient {

        info!(
            "Bulk deprecated {} key(s) for {} servers in flow '{}'",
-            affected, server_names.len(), flow_name
+            affected,
+            server_names.len(),
+            flow_name
        );

        Ok(affected)
@@ -526,7 +528,9 @@ impl DbClient {

        info!(
            "Bulk restored {} key(s) for {} servers in flow '{}'",
-            affected, server_names.len(), flow_name
+            affected,
+            server_names.len(),
+            flow_name
        );

        Ok(affected)
--- a/src/gui/admin/mod.rs
+++ b/src/gui/admin/mod.rs
@@ -1,5 +1,9 @@
+#[cfg(feature = "gui")]
 mod state;
+#[cfg(feature = "gui")]
 mod ui;

+#[cfg(feature = "gui")]
 pub use state::*;
+#[cfg(feature = "gui")]
 pub use ui::*;
--- a/src/gui/admin/state.rs
+++ b/src/gui/admin/state.rs
@@ -1,9 +1,9 @@
+use crate::gui::api::{fetch_keys, SshKey};
+use crate::gui::common::KhmSettings;
 use eframe::egui;
 use log::{error, info};
 use std::collections::HashMap;
 use std::sync::mpsc;
-use crate::gui::api::{SshKey, fetch_keys};
-use crate::gui::common::KhmSettings;

 #[derive(Debug, Clone)]
 pub enum AdminOperation {
@@ -57,8 +57,8 @@ impl AdminState {
        if !self.search_term.is_empty() {
            let search_term = self.search_term.to_lowercase();
            filtered.retain(|key| {
-                key.server.to_lowercase().contains(&search_term) ||
-                key.public_key.to_lowercase().contains(&search_term)
+                key.server.to_lowercase().contains(&search_term)
+                    || key.public_key.to_lowercase().contains(&search_term)
            });
        }

@@ -66,7 +66,11 @@ impl AdminState {
    }

    /// Load keys from server
-    pub fn load_keys(&mut self, settings: &KhmSettings, ctx: &egui::Context) -> Option<mpsc::Receiver<Result<Vec<SshKey>, String>>> {
+    pub fn load_keys(
+        &mut self,
+        settings: &KhmSettings,
+        ctx: &egui::Context,
+    ) -> Option<mpsc::Receiver<Result<Vec<SshKey>, String>>> {
        if settings.host.is_empty() || settings.flow.is_empty() {
            return None;
        }
@@ -82,9 +86,7 @@ impl AdminState {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                fetch_keys(host, flow, basic_auth).await
-            });
+            let result = rt.block_on(async { fetch_keys(host, flow, basic_auth).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -128,7 +130,12 @@ impl AdminState {
        let total_keys = self.keys.len();
        let active_keys = self.keys.iter().filter(|k| !k.deprecated).count();
        let deprecated_keys = total_keys - active_keys;
-        let unique_servers = self.keys.iter().map(|k| &k.server).collect::<std::collections::HashSet<_>>().len();
+        let unique_servers = self
+            .keys
+            .iter()
+            .map(|k| &k.server)
+            .collect::<std::collections::HashSet<_>>()
+            .len();

        AdminStatistics {
            total_keys,
--- a/src/gui/admin/ui.rs
+++ b/src/gui/admin/ui.rs
@@ -1,7 +1,7 @@
+use super::state::{get_key_preview, get_key_type, AdminState};
+use crate::gui::api::SshKey;
 use eframe::egui;
 use std::collections::BTreeMap;
-use super::state::{AdminState, get_key_type, get_key_preview};
-use crate::gui::api::SshKey;

 /// Render statistics cards
 pub fn render_statistics(ui: &mut egui::Ui, admin_state: &AdminState) {
@@ -18,29 +18,64 @@ pub fn render_statistics(ui: &mut egui::Ui, admin_state: &AdminState) {
                    // Total keys
                    cols[0].vertical_centered_justified(|ui| {
                        ui.label(egui::RichText::new("📊").size(20.0));
-                        ui.label(egui::RichText::new(stats.total_keys.to_string()).size(24.0).strong());
-                        ui.label(egui::RichText::new("Total Keys").size(11.0).color(egui::Color32::GRAY));
+                        ui.label(
+                            egui::RichText::new(stats.total_keys.to_string())
+                                .size(24.0)
+                                .strong(),
+                        );
+                        ui.label(
+                            egui::RichText::new("Total Keys")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
                    });

                    // Active keys
                    cols[1].vertical_centered_justified(|ui| {
                        ui.label(egui::RichText::new("✅").size(20.0));
-                        ui.label(egui::RichText::new(stats.active_keys.to_string()).size(24.0).strong().color(egui::Color32::LIGHT_GREEN));
-                        ui.label(egui::RichText::new("Active").size(11.0).color(egui::Color32::GRAY));
+                        ui.label(
+                            egui::RichText::new(stats.active_keys.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_GREEN),
+                        );
+                        ui.label(
+                            egui::RichText::new("Active")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
                    });

                    // Deprecated keys
                    cols[2].vertical_centered_justified(|ui| {
                        ui.label(egui::RichText::new("❌").size(20.0));
-                        ui.label(egui::RichText::new(stats.deprecated_keys.to_string()).size(24.0).strong().color(egui::Color32::LIGHT_RED));
-                        ui.label(egui::RichText::new("Deprecated").size(11.0).color(egui::Color32::GRAY));
+                        ui.label(
+                            egui::RichText::new(stats.deprecated_keys.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_RED),
+                        );
+                        ui.label(
+                            egui::RichText::new("Deprecated")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
                    });

                    // Servers
                    cols[3].vertical_centered_justified(|ui| {
                        ui.label(egui::RichText::new("💻").size(20.0));
-                        ui.label(egui::RichText::new(stats.unique_servers.to_string()).size(24.0).strong().color(egui::Color32::LIGHT_BLUE));
-                        ui.label(egui::RichText::new("Servers").size(11.0).color(egui::Color32::GRAY));
+                        ui.label(
+                            egui::RichText::new(stats.unique_servers.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_BLUE),
+                        );
+                        ui.label(
+                            egui::RichText::new("Servers")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
                    });
                });
            });
@@ -64,19 +99,33 @@ pub fn render_search_controls(ui: &mut egui::Ui, admin_state: &mut AdminState) -
                let search_response = ui.add_sized(
                    [ui.available_width() * 0.6, 20.0],
                    egui::TextEdit::singleline(&mut admin_state.search_term)
-                        .hint_text("Search servers or keys...")
+                        .hint_text("Search servers or keys..."),
                );

                if admin_state.search_term.is_empty() {
-                    ui.label(egui::RichText::new("Type to search").size(11.0).color(egui::Color32::GRAY));
+                    ui.label(
+                        egui::RichText::new("Type to search")
+                            .size(11.0)
+                            .color(egui::Color32::GRAY),
+                    );
                } else {
-                    ui.label(egui::RichText::new(format!("{} results", admin_state.filtered_keys.len())).size(11.0));
-                    if ui.add(egui::Button::new(egui::RichText::new("❌").color(egui::Color32::WHITE))
-                        .fill(egui::Color32::from_rgb(170, 170, 170))
-                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(89, 89, 89)))
-                        .rounding(egui::Rounding::same(3.0))
-                        .min_size(egui::vec2(18.0, 18.0))
-                    ).on_hover_text("Clear search").clicked() {
+                    ui.label(
+                        egui::RichText::new(format!("{} results", admin_state.filtered_keys.len()))
+                            .size(11.0),
+                    );
+                    if ui
+                        .add(
+                            egui::Button::new(
+                                egui::RichText::new("❌").color(egui::Color32::WHITE),
+                            )
+                            .fill(egui::Color32::from_rgb(170, 170, 170))
+                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(89, 89, 89)))
+                            .rounding(egui::Rounding::same(3.0))
+                            .min_size(egui::vec2(18.0, 18.0)),
+                        )
+                        .on_hover_text("Clear search")
+                        .clicked()
+                    {
                        admin_state.search_term.clear();
                        changed = true;
                    }
@@ -98,7 +147,10 @@ pub fn render_search_controls(ui: &mut egui::Ui, admin_state: &mut AdminState) -
                    admin_state.show_deprecated_only = false;
                    changed = true;
                }
-                if ui.selectable_label(show_deprecated, "❗ Deprecated").clicked() {
+                if ui
+                    .selectable_label(show_deprecated, "❗ Deprecated")
+                    .clicked()
+                {
                    admin_state.show_deprecated_only = true;
                    changed = true;
                }
@@ -115,7 +167,11 @@ pub fn render_search_controls(ui: &mut egui::Ui, admin_state: &mut AdminState) -

 /// Render bulk actions controls
 pub fn render_bulk_actions(ui: &mut egui::Ui, admin_state: &mut AdminState) -> BulkAction {
-    let selected_count = admin_state.selected_servers.values().filter(|&&v| v).count();
+    let selected_count = admin_state
+        .selected_servers
+        .values()
+        .filter(|&&v| v)
+        .count();

    if selected_count == 0 {
        return BulkAction::None;
@@ -128,39 +184,60 @@ pub fn render_bulk_actions(ui: &mut egui::Ui, admin_state: &mut AdminState) -> B
        ui.vertical(|ui| {
            ui.horizontal(|ui| {
                ui.label(egui::RichText::new("📋").size(14.0));
-                ui.label(egui::RichText::new(format!("Selected {} servers", selected_count))
-                    .size(14.0)
-                    .strong()
-                    .color(egui::Color32::LIGHT_BLUE));
+                ui.label(
+                    egui::RichText::new(format!("Selected {} servers", selected_count))
+                        .size(14.0)
+                        .strong()
+                        .color(egui::Color32::LIGHT_BLUE),
+                );
            });

            ui.add_space(5.0);

            ui.horizontal(|ui| {
-                if ui.add(egui::Button::new(egui::RichText::new("❗ Deprecate Selected").color(egui::Color32::BLACK))
-                    .fill(egui::Color32::from_rgb(255, 200, 0))
-                    .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(102, 94, 72)))
-                    .rounding(egui::Rounding::same(6.0))
-                    .min_size(egui::vec2(130.0, 28.0))
-                ).clicked() {
+                if ui
+                    .add(
+                        egui::Button::new(
+                            egui::RichText::new("❗ Deprecate Selected")
+                                .color(egui::Color32::BLACK),
+                        )
+                        .fill(egui::Color32::from_rgb(255, 200, 0))
+                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(102, 94, 72)))
+                        .rounding(egui::Rounding::same(6.0))
+                        .min_size(egui::vec2(130.0, 28.0)),
+                    )
+                    .clicked()
+                {
                    action = BulkAction::DeprecateSelected;
                }

-                if ui.add(egui::Button::new(egui::RichText::new("✅ Restore Selected").color(egui::Color32::WHITE))
-                    .fill(egui::Color32::from_rgb(101, 199, 40))
-                    .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(94, 105, 25)))
-                    .rounding(egui::Rounding::same(6.0))
-                    .min_size(egui::vec2(120.0, 28.0))
-                ).clicked() {
+                if ui
+                    .add(
+                        egui::Button::new(
+                            egui::RichText::new("✅ Restore Selected").color(egui::Color32::WHITE),
+                        )
+                        .fill(egui::Color32::from_rgb(101, 199, 40))
+                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(94, 105, 25)))
+                        .rounding(egui::Rounding::same(6.0))
+                        .min_size(egui::vec2(120.0, 28.0)),
+                    )
+                    .clicked()
+                {
                    action = BulkAction::RestoreSelected;
                }

-                if ui.add(egui::Button::new(egui::RichText::new("X Clear Selection").color(egui::Color32::WHITE))
-                    .fill(egui::Color32::from_rgb(170, 170, 170))
-                    .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(89, 89, 89)))
-                    .rounding(egui::Rounding::same(6.0))
-                    .min_size(egui::vec2(110.0, 28.0))
-                ).clicked() {
+                if ui
+                    .add(
+                        egui::Button::new(
+                            egui::RichText::new("X Clear Selection").color(egui::Color32::WHITE),
+                        )
+                        .fill(egui::Color32::from_rgb(170, 170, 170))
+                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(89, 89, 89)))
+                        .rounding(egui::Rounding::same(6.0))
+                        .min_size(egui::vec2(110.0, 28.0)),
+                    )
+                    .clicked()
+                {
                    admin_state.clear_selection();
                    action = BulkAction::ClearSelection;
                }
@@ -183,12 +260,19 @@ pub fn render_keys_table(ui: &mut egui::Ui, admin_state: &mut AdminState) -> Key
    // Group keys by server
    let mut servers: BTreeMap<String, Vec<SshKey>> = BTreeMap::new();
    for key in &admin_state.filtered_keys {
-        servers.entry(key.server.clone()).or_insert_with(Vec::new).push(key.clone());
+        servers
+            .entry(key.server.clone())
+            .or_insert_with(Vec::new)
+            .push(key.clone());
    }

    // Render each server group
    for (server_name, server_keys) in servers {
-        let is_expanded = admin_state.expanded_servers.get(&server_name).copied().unwrap_or(false);
+        let is_expanded = admin_state
+            .expanded_servers
+            .get(&server_name)
+            .copied()
+            .unwrap_or(false);
        let active_count = server_keys.iter().filter(|k| !k.deprecated).count();
        let deprecated_count = server_keys.len() - active_count;

@@ -196,60 +280,103 @@ pub fn render_keys_table(ui: &mut egui::Ui, admin_state: &mut AdminState) -> Key
        ui.group(|ui| {
            ui.horizontal(|ui| {
                // Server selection checkbox
-                let mut selected = admin_state.selected_servers.get(&server_name).copied().unwrap_or(false);
-                if ui.add(egui::Checkbox::new(&mut selected, "")
-                    .indeterminate(false)
-                ).changed() {
-                    admin_state.selected_servers.insert(server_name.clone(), selected);
+                let mut selected = admin_state
+                    .selected_servers
+                    .get(&server_name)
+                    .copied()
+                    .unwrap_or(false);
+                if ui
+                    .add(egui::Checkbox::new(&mut selected, "").indeterminate(false))
+                    .changed()
+                {
+                    admin_state
+                        .selected_servers
+                        .insert(server_name.clone(), selected);
                }

                // Expand/collapse button
-                let expand_icon = if is_expanded { "▼" } else { "▶" };
-                if ui.add(egui::Button::new(expand_icon)
-                    .fill(egui::Color32::TRANSPARENT)
-                    .stroke(egui::Stroke::NONE)
-                    .min_size(egui::vec2(20.0, 20.0))
-                ).clicked() {
-                    admin_state.expanded_servers.insert(server_name.clone(), !is_expanded);
+                let expand_icon = if is_expanded { "-" } else { "+" };
+                if ui
+                    .add(
+                        egui::Button::new(expand_icon)
+                            .fill(egui::Color32::TRANSPARENT)
+                            .stroke(egui::Stroke::NONE)
+                            .min_size(egui::vec2(20.0, 20.0)),
+                    )
+                    .clicked()
+                {
+                    admin_state
+                        .expanded_servers
+                        .insert(server_name.clone(), !is_expanded);
                }

                // Server icon and name
                ui.label(egui::RichText::new("💻").size(16.0));
-                ui.label(egui::RichText::new(&server_name)
-                    .size(15.0)
-                    .strong()
-                    .color(egui::Color32::WHITE));
+                ui.label(
+                    egui::RichText::new(&server_name)
+                        .size(15.0)
+                        .strong()
+                        .color(egui::Color32::WHITE),
+                );

                // Keys count badge
-                render_badge(ui, &format!("{} keys", server_keys.len()), egui::Color32::from_rgb(52, 152, 219), egui::Color32::WHITE);
+                render_badge(
+                    ui,
+                    &format!("{} keys", server_keys.len()),
+                    egui::Color32::from_rgb(52, 152, 219),
+                    egui::Color32::WHITE,
+                );

                ui.add_space(5.0);

                // Deprecated count badge
                if deprecated_count > 0 {
-                    render_badge(ui, &format!("{} depr", deprecated_count), egui::Color32::from_rgb(231, 76, 60), egui::Color32::WHITE);
+                    render_badge(
+                        ui,
+                        &format!("{} depr", deprecated_count),
+                        egui::Color32::from_rgb(231, 76, 60),
+                        egui::Color32::WHITE,
+                    );
                }

                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    // Server action buttons
                    if deprecated_count > 0 {
-                        if ui.add(egui::Button::new(egui::RichText::new("✅ Restore").color(egui::Color32::WHITE))
-                            .fill(egui::Color32::from_rgb(101, 199, 40))
-                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(94, 105, 25)))
-                            .rounding(egui::Rounding::same(4.0))
-                            .min_size(egui::vec2(70.0, 24.0))
-                        ).clicked() {
+                        if ui
+                            .add(
+                                egui::Button::new(
+                                    egui::RichText::new("✅ Restore").color(egui::Color32::WHITE),
+                                )
+                                .fill(egui::Color32::from_rgb(101, 199, 40))
+                                .stroke(egui::Stroke::new(
+                                    1.0,
+                                    egui::Color32::from_rgb(94, 105, 25),
+                                ))
+                                .rounding(egui::Rounding::same(4.0))
+                                .min_size(egui::vec2(70.0, 24.0)),
+                            )
+                            .clicked()
+                        {
                            action = KeyAction::RestoreServer(server_name.clone());
                        }
                    }

                    if active_count > 0 {
-                        if ui.add(egui::Button::new(egui::RichText::new("❗ Deprecate").color(egui::Color32::BLACK))
-                            .fill(egui::Color32::from_rgb(255, 200, 0))
-                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(102, 94, 72)))
-                            .rounding(egui::Rounding::same(4.0))
-                            .min_size(egui::vec2(85.0, 24.0))
-                        ).clicked() {
+                        if ui
+                            .add(
+                                egui::Button::new(
+                                    egui::RichText::new("❗ Deprecate").color(egui::Color32::BLACK),
+                                )
+                                .fill(egui::Color32::from_rgb(255, 200, 0))
+                                .stroke(egui::Stroke::new(
+                                    1.0,
+                                    egui::Color32::from_rgb(102, 94, 72),
+                                ))
+                                .rounding(egui::Rounding::same(4.0))
+                                .min_size(egui::vec2(85.0, 24.0)),
+                            )
+                            .clicked()
+                        {
                            action = KeyAction::DeprecateServer(server_name.clone());
                        }
                    }
@@ -279,29 +406,56 @@ fn render_empty_state(ui: &mut egui::Ui, admin_state: &AdminState) {
    ui.vertical_centered(|ui| {
        ui.add_space(60.0);
        if admin_state.keys.is_empty() {
-            ui.label(egui::RichText::new("🔑").size(48.0).color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new("No SSH keys available")
-                .size(18.0)
-                .color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new("Keys will appear here once loaded from the server")
-                .size(14.0)
-                .color(egui::Color32::DARK_GRAY));
+            ui.label(
+                egui::RichText::new("🔑")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No SSH keys available")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("Keys will appear here once loaded from the server")
+                    .size(14.0)
+                    .color(egui::Color32::DARK_GRAY),
+            );
        } else if !admin_state.search_term.is_empty() {
-            ui.label(egui::RichText::new("🔍").size(48.0).color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new("No results found")
-                .size(18.0)
-                .color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new(format!("Try adjusting your search: '{}'", admin_state.search_term))
+            ui.label(
+                egui::RichText::new("🔍")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No results found")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new(format!(
+                    "Try adjusting your search: '{}'",
+                    admin_state.search_term
+                ))
                .size(14.0)
-                .color(egui::Color32::DARK_GRAY));
+                .color(egui::Color32::DARK_GRAY),
+            );
        } else {
-            ui.label(egui::RichText::new("❌").size(48.0).color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new("No keys match current filters")
-                .size(18.0)
-                .color(egui::Color32::GRAY));
-            ui.label(egui::RichText::new("Try adjusting your search or filter settings")
-                .size(14.0)
-                .color(egui::Color32::DARK_GRAY));
+            ui.label(
+                egui::RichText::new("❌")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No keys match current filters")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("Try adjusting your search or filter settings")
+                    .size(14.0)
+                    .color(egui::Color32::DARK_GRAY),
+            );
        }
    });
 }
@@ -327,60 +481,92 @@ fn render_key_item(ui: &mut egui::Ui, key: &SshKey, server_name: &str) -> Option

            // Status badge
            if key.deprecated {
-                ui.label(egui::RichText::new("❗ DEPR")
-                    .size(10.0)
-                    .color(egui::Color32::from_rgb(231, 76, 60))
-                    .strong());
+                ui.label(
+                    egui::RichText::new("❗ DEPR")
+                        .size(10.0)
+                        .color(egui::Color32::from_rgb(231, 76, 60))
+                        .strong(),
+                );
            } else {
-                ui.label(egui::RichText::new("[OK] ACTIVE")
-                    .size(10.0)
-                    .color(egui::Color32::from_rgb(46, 204, 113))
-                    .strong());
+                ui.label(
+                    egui::RichText::new("✅")
+                        .size(10.0)
+                        .color(egui::Color32::from_rgb(46, 204, 113))
+                        .strong(),
+                );
            }

            ui.add_space(5.0);

            // Key preview
-            ui.label(egui::RichText::new(get_key_preview(&key.public_key))
-                .font(egui::FontId::monospace(10.0))
-                .color(egui::Color32::LIGHT_GRAY));
+            ui.label(
+                egui::RichText::new(get_key_preview(&key.public_key))
+                    .font(egui::FontId::monospace(10.0))
+                    .color(egui::Color32::LIGHT_GRAY),
+            );

            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                // Key action buttons
                if key.deprecated {
-                    if ui.add(egui::Button::new(egui::RichText::new("[R]").color(egui::Color32::WHITE))
-                        .fill(egui::Color32::from_rgb(101, 199, 40))
-                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(94, 105, 25)))
-                        .rounding(egui::Rounding::same(3.0))
-                        .min_size(egui::vec2(22.0, 18.0))
-                    ).on_hover_text("Restore key").clicked() {
+                    if ui
+                        .add(
+                            egui::Button::new(
+                                egui::RichText::new("[R]").color(egui::Color32::WHITE),
+                            )
+                            .fill(egui::Color32::from_rgb(101, 199, 40))
+                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(94, 105, 25)))
+                            .rounding(egui::Rounding::same(3.0))
+                            .min_size(egui::vec2(22.0, 18.0)),
+                        )
+                        .on_hover_text("Restore key")
+                        .clicked()
+                    {
                        action = Some(KeyAction::RestoreKey(server_name.to_string()));
                    }
-                    if ui.add(egui::Button::new(egui::RichText::new("Del").color(egui::Color32::WHITE))
-                        .fill(egui::Color32::from_rgb(246, 36, 71))
-                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(129, 18, 17)))
-                        .rounding(egui::Rounding::same(3.0))
-                        .min_size(egui::vec2(26.0, 18.0))
-                    ).on_hover_text("Delete key").clicked() {
+                    if ui
+                        .add(
+                            egui::Button::new(
+                                egui::RichText::new("Del").color(egui::Color32::WHITE),
+                            )
+                            .fill(egui::Color32::from_rgb(246, 36, 71))
+                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(129, 18, 17)))
+                            .rounding(egui::Rounding::same(3.0))
+                            .min_size(egui::vec2(26.0, 18.0)),
+                        )
+                        .on_hover_text("Delete key")
+                        .clicked()
+                    {
                        action = Some(KeyAction::DeleteKey(server_name.to_string()));
                    }
                } else {
-                    if ui.add(egui::Button::new(egui::RichText::new("❗").color(egui::Color32::BLACK))
-                        .fill(egui::Color32::from_rgb(255, 200, 0))
-                        .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(102, 94, 72)))
-                        .rounding(egui::Rounding::same(3.0))
-                        .min_size(egui::vec2(22.0, 18.0))
-                    ).on_hover_text("Deprecate key").clicked() {
+                    if ui
+                        .add(
+                            egui::Button::new(
+                                egui::RichText::new("❗").color(egui::Color32::BLACK),
+                            )
+                            .fill(egui::Color32::from_rgb(255, 200, 0))
+                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(102, 94, 72)))
+                            .rounding(egui::Rounding::same(3.0))
+                            .min_size(egui::vec2(22.0, 18.0)),
+                        )
+                        .on_hover_text("Deprecate key")
+                        .clicked()
+                    {
                        action = Some(KeyAction::DeprecateKey(server_name.to_string()));
                    }
                }

-                if ui.add(egui::Button::new(egui::RichText::new("Copy").color(egui::Color32::WHITE))
-                    .fill(egui::Color32::from_rgb(0, 111, 230))
-                    .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(35, 84, 97)))
-                    .rounding(egui::Rounding::same(3.0))
-                    .min_size(egui::vec2(30.0, 18.0))
-                ).on_hover_text("Copy to clipboard").clicked() {
+                if ui
+                    .add(
+                        egui::Button::new(egui::RichText::new("Copy").color(egui::Color32::WHITE))
+                            .fill(egui::Color32::from_rgb(0, 111, 230))
+                            .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(35, 84, 97)))
+                            .rounding(egui::Rounding::same(3.0))
+                            .min_size(egui::vec2(30.0, 18.0)),
+                    )
+                    .on_hover_text("Copy to clipboard")
+                    .clicked()
+                {
                    ui.output_mut(|o| o.copied_text = key.public_key.clone());
                }
            });
@@ -392,15 +578,9 @@ fn render_key_item(ui: &mut egui::Ui, key: &SshKey, server_name: &str) -> Option

 /// Render a badge with text
 fn render_badge(ui: &mut egui::Ui, text: &str, bg_color: egui::Color32, text_color: egui::Color32) {
-    let (rect, _) = ui.allocate_exact_size(
-        egui::vec2(50.0, 18.0),
-        egui::Sense::hover()
-    );
-    ui.painter().rect_filled(
-        rect,
-        egui::Rounding::same(8.0),
-        bg_color
-    );
+    let (rect, _) = ui.allocate_exact_size(egui::vec2(50.0, 18.0), egui::Sense::hover());
+    ui.painter()
+        .rect_filled(rect, egui::Rounding::same(8.0), bg_color);
    ui.painter().text(
        rect.center(),
        egui::Align2::CENTER_CENTER,
@@ -411,16 +591,15 @@ fn render_badge(ui: &mut egui::Ui, text: &str, bg_color: egui::Color32, text_col
 }

 /// Render a small badge with text
-fn render_small_badge(ui: &mut egui::Ui, text: &str, bg_color: egui::Color32, text_color: egui::Color32) {
-    let (rect, _) = ui.allocate_exact_size(
-        egui::vec2(40.0, 16.0),
-        egui::Sense::hover()
-    );
-    ui.painter().rect_filled(
-        rect,
-        egui::Rounding::same(3.0),
-        bg_color
-    );
+fn render_small_badge(
+    ui: &mut egui::Ui,
+    text: &str,
+    bg_color: egui::Color32,
+    text_color: egui::Color32,
+) {
+    let (rect, _) = ui.allocate_exact_size(egui::vec2(40.0, 16.0), egui::Sense::hover());
+    ui.painter()
+        .rect_filled(rect, egui::Rounding::same(3.0), bg_color);
    ui.painter().text(
        rect.center(),
        egui::Align2::CENTER_CENTER,
--- a/src/gui/api/client.rs
+++ b/src/gui/api/client.rs
@@ -1,7 +1,7 @@
-use reqwest::Client;
+use crate::gui::common::{perform_sync, KhmSettings};
 use log::info;
+use reqwest::Client;
 use serde::{Deserialize, Serialize};
-use crate::gui::common::{KhmSettings, perform_sync};

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SshKey {
@@ -12,7 +12,12 @@ pub struct SshKey {
 }

 /// Test connection to KHM server
-pub async fn test_connection(host: String, flow: String, basic_auth: String) -> Result<String, String> {
+#[cfg(feature = "gui")]
+pub async fn test_connection(
+    host: String,
+    flow: String,
+    basic_auth: String,
+) -> Result<String, String> {
    if host.is_empty() || flow.is_empty() {
        return Err("Host and flow must be specified".to_string());
    }
@@ -25,18 +30,22 @@ pub async fn test_connection(host: String, flow: String, basic_auth: String) ->

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

    check_html_response(&body)?;

-    let keys: Vec<SshKey> = serde_json::from_str(&body)
-        .map_err(|e| format!("Failed to parse response: {}", e))?;
+    let keys: Vec<SshKey> =
+        serde_json::from_str(&body).map_err(|e| format!("Failed to parse response: {}", e))?;

    let message = format!("Found {} SSH keys from flow '{}'", keys.len(), flow);
    info!("Connection test successful: {}", message);
@@ -44,12 +53,21 @@ pub async fn test_connection(host: String, flow: String, basic_auth: String) ->
 }

 /// Fetch all SSH keys including deprecated ones
-pub async fn fetch_keys(host: String, flow: String, basic_auth: String) -> Result<Vec<SshKey>, String> {
+#[cfg(feature = "gui")]
+pub async fn fetch_keys(
+    host: String,
+    flow: String,
+    basic_auth: String,
+) -> Result<Vec<SshKey>, String> {
    if host.is_empty() || flow.is_empty() {
        return Err("Host and flow must be specified".to_string());
    }

-    let url = format!("{}/{}/keys?include_deprecated=true", host.trim_end_matches('/'), flow);
+    let url = format!(
+        "{}/{}/keys?include_deprecated=true",
+        host.trim_end_matches('/'),
+        flow
+    );
    info!("Fetching keys from: {}", url);

    let client = create_http_client()?;
@@ -57,26 +75,41 @@ pub async fn fetch_keys(host: String, flow: String, basic_auth: String) -> Resul

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

    check_html_response(&body)?;

-    let keys: Vec<SshKey> = serde_json::from_str(&body)
-        .map_err(|e| format!("Failed to parse response: {}", e))?;
+    let keys: Vec<SshKey> =
+        serde_json::from_str(&body).map_err(|e| format!("Failed to parse response: {}", e))?;

    info!("Fetched {} SSH keys", keys.len());
    Ok(keys)
 }

 /// Deprecate a key for a specific server
-pub async fn deprecate_key(host: String, flow: String, basic_auth: String, server: String) -> Result<String, String> {
-    let url = format!("{}/{}/keys/{}", host.trim_end_matches('/'), flow, urlencoding::encode(&server));
+#[cfg(feature = "gui")]
+pub async fn deprecate_key(
+    host: String,
+    flow: String,
+    basic_auth: String,
+    server: String,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}",
+        host.trim_end_matches('/'),
+        flow,
+        urlencoding::encode(&server)
+    );
    info!("Deprecating key for server '{}' at: {}", server, url);

    let client = create_http_client()?;
@@ -84,20 +117,38 @@ pub async fn deprecate_key(host: String, flow: String, basic_auth: String, serve

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

-    parse_api_response(&body, &format!("Successfully deprecated key for server '{}'", server))
+    parse_api_response(
+        &body,
+        &format!("Successfully deprecated key for server '{}'", server),
+    )
 }

 /// Restore a key for a specific server
-pub async fn restore_key(host: String, flow: String, basic_auth: String, server: String) -> Result<String, String> {
-    let url = format!("{}/{}/keys/{}/restore", host.trim_end_matches('/'), flow, urlencoding::encode(&server));
+#[cfg(feature = "gui")]
+pub async fn restore_key(
+    host: String,
+    flow: String,
+    basic_auth: String,
+    server: String,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}/restore",
+        host.trim_end_matches('/'),
+        flow,
+        urlencoding::encode(&server)
+    );
    info!("Restoring key for server '{}' at: {}", server, url);

    let client = create_http_client()?;
@@ -105,96 +156,147 @@ pub async fn restore_key(host: String, flow: String, basic_auth: String, server:

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

-    parse_api_response(&body, &format!("Successfully restored key for server '{}'", server))
+    parse_api_response(
+        &body,
+        &format!("Successfully restored key for server '{}'", server),
+    )
 }

 /// Delete a key permanently for a specific server
-pub async fn delete_key(host: String, flow: String, basic_auth: String, server: String) -> Result<String, String> {
-    let url = format!("{}/{}/keys/{}/delete", host.trim_end_matches('/'), flow, urlencoding::encode(&server));
-    info!("Permanently deleting key for server '{}' at: {}", server, url);
+#[cfg(feature = "gui")]
+pub async fn delete_key(
+    host: String,
+    flow: String,
+    basic_auth: String,
+    server: String,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}/delete",
+        host.trim_end_matches('/'),
+        flow,
+        urlencoding::encode(&server)
+    );
+    info!(
+        "Permanently deleting key for server '{}' at: {}",
+        server, url
+    );

    let client = create_http_client()?;
    let mut request = client.delete(&url);

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

-    parse_api_response(&body, &format!("Successfully deleted key for server '{}'", server))
+    parse_api_response(
+        &body,
+        &format!("Successfully deleted key for server '{}'", server),
+    )
 }

 /// Bulk deprecate multiple servers
-pub async fn bulk_deprecate_servers(host: String, flow: String, basic_auth: String, servers: Vec<String>) -> Result<String, String> {
+#[cfg(feature = "gui")]
+pub async fn bulk_deprecate_servers(
+    host: String,
+    flow: String,
+    basic_auth: String,
+    servers: Vec<String>,
+) -> Result<String, String> {
    let url = format!("{}/{}/bulk-deprecate", host.trim_end_matches('/'), flow);
    info!("Bulk deprecating {} servers at: {}", servers.len(), url);

    let client = create_http_client()?;
-    let mut request = client.post(&url)
-        .json(&serde_json::json!({
-            "servers": servers
-        }));
+    let mut request = client.post(&url).json(&serde_json::json!({
+        "servers": servers
+    }));

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

    parse_api_response(&body, "Successfully deprecated servers")
 }

 /// Bulk restore multiple servers
-pub async fn bulk_restore_servers(host: String, flow: String, basic_auth: String, servers: Vec<String>) -> Result<String, String> {
+#[cfg(feature = "gui")]
+pub async fn bulk_restore_servers(
+    host: String,
+    flow: String,
+    basic_auth: String,
+    servers: Vec<String>,
+) -> Result<String, String> {
    let url = format!("{}/{}/bulk-restore", host.trim_end_matches('/'), flow);
    info!("Bulk restoring {} servers at: {}", servers.len(), url);

    let client = create_http_client()?;
-    let mut request = client.post(&url)
-        .json(&serde_json::json!({
-            "servers": servers
-        }));
+    let mut request = client.post(&url).json(&serde_json::json!({
+        "servers": servers
+    }));

    request = add_auth_if_needed(request, &basic_auth)?;

-    let response = request.send().await
+    let response = request
+        .send()
+        .await
        .map_err(|e| format!("Request failed: {}", e))?;

    check_response_status(&response)?;

-    let body = response.text().await
+    let body = response
+        .text()
+        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

    parse_api_response(&body, "Successfully restored servers")
 }

 /// Perform manual sync operation
+#[cfg(feature = "gui")]
 pub async fn perform_manual_sync(settings: KhmSettings) -> Result<String, String> {
    match perform_sync(&settings).await {
-        Ok(keys_count) => Ok(format!("Sync completed successfully with {} keys", keys_count)),
+        Ok(keys_count) => Ok(format!(
+            "Sync completed successfully with {} keys",
+            keys_count
+        )),
        Err(e) => Err(e.to_string()),
    }
 }

 // Helper functions

+#[cfg(feature = "gui")]
 fn create_http_client() -> Result<Client, String> {
    Client::builder()
        .timeout(std::time::Duration::from_secs(30))
@@ -203,7 +305,11 @@ fn create_http_client() -> Result<Client, String> {
        .map_err(|e| format!("Failed to create HTTP client: {}", e))
 }

-fn add_auth_if_needed(request: reqwest::RequestBuilder, basic_auth: &str) -> Result<reqwest::RequestBuilder, String> {
+#[cfg(feature = "gui")]
+fn add_auth_if_needed(
+    request: reqwest::RequestBuilder,
+    basic_auth: &str,
+) -> Result<reqwest::RequestBuilder, String> {
    if basic_auth.is_empty() {
        return Ok(request);
    }
@@ -216,11 +322,14 @@ fn add_auth_if_needed(request: reqwest::RequestBuilder, basic_auth: &str) -> Res
    }
 }

+#[cfg(feature = "gui")]
 fn check_response_status(response: &reqwest::Response) -> Result<(), String> {
    let status = response.status().as_u16();

    if status == 401 {
-        return Err("Authentication required. Please provide valid basic auth credentials.".to_string());
+        return Err(
+            "Authentication required. Please provide valid basic auth credentials.".to_string(),
+        );
    }

    if status >= 300 && status < 400 {
@@ -228,12 +337,17 @@ fn check_response_status(response: &reqwest::Response) -> Result<(), String> {
    }

    if !response.status().is_success() {
-        return Err(format!("Server returned error: {} {}", status, response.status().canonical_reason().unwrap_or("Unknown")));
+        return Err(format!(
+            "Server returned error: {} {}",
+            status,
+            response.status().canonical_reason().unwrap_or("Unknown")
+        ));
    }

    Ok(())
 }

+#[cfg(feature = "gui")]
 fn check_html_response(body: &str) -> Result<(), String> {
    if body.trim_start().starts_with("<!DOCTYPE") || body.trim_start().starts_with("<html") {
        return Err("Server returned HTML page instead of JSON. This usually means authentication is required or the endpoint is incorrect.".to_string());
@@ -241,6 +355,7 @@ fn check_html_response(body: &str) -> Result<(), String> {
    Ok(())
 }

+#[cfg(feature = "gui")]
 fn parse_api_response(body: &str, default_message: &str) -> Result<String, String> {
    if let Ok(json_response) = serde_json::from_str::<serde_json::Value>(body) {
        if let Some(message) = json_response.get("message").and_then(|v| v.as_str()) {
--- a/src/gui/api/mod.rs
+++ b/src/gui/api/mod.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "gui")]
 mod client;

+#[cfg(feature = "gui")]
 pub use client::*;
--- a/src/gui/common/mod.rs
+++ b/src/gui/common/mod.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "gui")]
 mod settings;

+#[cfg(feature = "gui")]
 pub use settings::*;
--- a/src/gui/common/settings.rs
+++ b/src/gui/common/settings.rs
@@ -1,9 +1,15 @@
+#[cfg(feature = "gui")]
 use dirs::home_dir;
+#[cfg(feature = "gui")]
 use log::{debug, error, info};
+#[cfg(feature = "gui")]
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "gui")]
 use std::fs;
+#[cfg(feature = "gui")]
 use std::path::PathBuf;

+#[cfg(feature = "gui")]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct KhmSettings {
    pub host: String,
@@ -14,6 +20,7 @@ pub struct KhmSettings {
    pub auto_sync_interval_minutes: u32,
 }

+#[cfg(feature = "gui")]
 impl Default for KhmSettings {
    fn default() -> Self {
        Self {
@@ -28,22 +35,19 @@ impl Default for KhmSettings {
 }

 /// Get default known_hosts file path based on OS
+#[cfg(feature = "gui")]
 fn get_default_known_hosts_path() -> String {
-    #[cfg(target_os = "windows")]
-    {
-        if let Ok(user_profile) = std::env::var("USERPROFILE") {
-            format!("{}/.ssh/known_hosts", user_profile)
-        } else {
-            "~/.ssh/known_hosts".to_string()
-        }
-    }
-    #[cfg(not(target_os = "windows"))]
-    {
+    if let Some(home) = home_dir() {
+        let ssh_dir = home.join(".ssh");
+        let known_hosts_file = ssh_dir.join("known_hosts");
+        known_hosts_file.to_string_lossy().to_string()
+    } else {
        "~/.ssh/known_hosts".to_string()
    }
 }

 /// Get configuration file path
+#[cfg(feature = "gui")]
 pub fn get_config_path() -> PathBuf {
    let mut path = home_dir().expect("Could not find home directory");
    path.push(".khm");
@@ -53,6 +57,7 @@ pub fn get_config_path() -> PathBuf {
 }

 /// Load settings from configuration file
+#[cfg(feature = "gui")]
 pub fn load_settings() -> KhmSettings {
    let path = get_config_path();
    match fs::read_to_string(&path) {
@@ -77,6 +82,7 @@ pub fn load_settings() -> KhmSettings {
 }

 /// Save settings to configuration file
+#[cfg(feature = "gui")]
 pub fn save_settings(settings: &KhmSettings) -> Result<(), std::io::Error> {
    let path = get_config_path();
    let json = serde_json::to_string_pretty(settings)?;
@@ -86,6 +92,7 @@ pub fn save_settings(settings: &KhmSettings) -> Result<(), std::io::Error> {
 }

 /// Expand path with ~ substitution
+#[cfg(feature = "gui")]
 pub fn expand_path(path: &str) -> String {
    if path.starts_with("~/") {
        if let Some(home) = home_dir() {
@@ -96,25 +103,28 @@ pub fn expand_path(path: &str) -> String {
 }

 /// Perform sync operation using KHM client logic
+#[cfg(feature = "gui")]
 pub async fn perform_sync(settings: &KhmSettings) -> Result<usize, std::io::Error> {
    use crate::Args;

-    info!("Starting sync with settings: host={}, flow={}, known_hosts={}, in_place={}", 
-          settings.host, settings.flow, settings.known_hosts, settings.in_place);
+    info!(
+        "Starting sync with settings: host={}, flow={}, known_hosts={}, in_place={}",
+        settings.host, settings.flow, settings.known_hosts, settings.in_place
+    );

    // Convert KhmSettings to Args for client module
    let args = Args {
        server: false,
-        gui: false,
+        daemon: false,
        settings_ui: false,
        in_place: settings.in_place,
        flows: vec!["default".to_string()], // Not used in client mode
-        ip: "127.0.0.1".to_string(),      // Not used in client mode
-        port: 8080,                       // Not used in client mode
-        db_host: "127.0.0.1".to_string(), // Not used in client mode
-        db_name: "khm".to_string(),       // Not used in client mode
-        db_user: None,                    // Not used in client mode
-        db_password: None,                // Not used in client mode
+        ip: "127.0.0.1".to_string(),        // Not used in client mode
+        port: 8080,                         // Not used in client mode
+        db_host: "127.0.0.1".to_string(),   // Not used in client mode
+        db_name: "khm".to_string(),         // Not used in client mode
+        db_user: None,                      // Not used in client mode
+        db_password: None,                  // Not used in client mode
        host: Some(settings.host.clone()),
        flow: Some(settings.flow.clone()),
        known_hosts: expand_path(&settings.known_hosts),
@@ -138,6 +148,9 @@ pub async fn perform_sync(settings: &KhmSettings) -> Result<usize, std::io::Erro
        keys_before
    };

-    info!("Sync completed: {} keys before, {} keys after", keys_before, keys_after);
+    info!(
+        "Sync completed: {} keys before, {} keys after",
+        keys_before, keys_after
+    );
    Ok(keys_after)
 }
--- a/src/gui/mod.rs
+++ b/src/gui/mod.rs
@@ -1,8 +1,10 @@
+#[cfg(feature = "gui")]
 use log::info;

 // Modules
-mod api;
+#[cfg(feature = "gui")]
 mod admin;
+mod api;
 mod common;

 #[cfg(feature = "gui")]
@@ -38,6 +40,6 @@ pub async fn run_gui() -> std::io::Result<()> {
 pub async fn run_gui() -> std::io::Result<()> {
    return Err(std::io::Error::new(
        std::io::ErrorKind::Unsupported,
-        "GUI features not compiled. Install system dependencies and rebuild with --features gui"
+        "GUI features not compiled. Install system dependencies and rebuild with --features gui",
    ));
 }
--- a/src/gui/settings/connection.rs
+++ b/src/gui/settings/connection.rs
@@ -1,8 +1,8 @@
+use crate::gui::api::{perform_manual_sync, test_connection};
+use crate::gui::common::{save_settings, KhmSettings};
 use eframe::egui;
 use log::{error, info};
 use std::sync::mpsc;
-use crate::gui::api::{test_connection, perform_manual_sync};
-use crate::gui::common::{KhmSettings, save_settings};

 #[derive(Debug, Clone)]
 pub enum ConnectionStatus {
@@ -31,6 +31,7 @@ pub struct ConnectionTab {
    pub is_syncing: bool,
    pub sync_result_receiver: Option<mpsc::Receiver<Result<String, String>>>,
    pub sync_status: SyncStatus,
+    pub should_auto_test: bool,
 }

 impl Default for ConnectionTab {
@@ -42,6 +43,7 @@ impl Default for ConnectionTab {
            is_syncing: false,
            sync_result_receiver: None,
            sync_status: SyncStatus::Unknown,
+            should_auto_test: false,
        }
    }
 }
@@ -66,9 +68,7 @@ impl ConnectionTab {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                test_connection(host, flow, basic_auth).await
-            });
+            let result = rt.block_on(async { test_connection(host, flow, basic_auth).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -92,17 +92,25 @@ impl ConnectionTab {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                perform_manual_sync(settings).await
-            });
+            let result = rt.block_on(async { perform_manual_sync(settings).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
        });
    }

-    /// Check for test/sync results
-    pub fn check_results(&mut self, ctx: &egui::Context, settings: &KhmSettings, operation_log: &mut Vec<String>) {
+    /// Check for test/sync results and handle auto-test
+    pub fn check_results(
+        &mut self,
+        ctx: &egui::Context,
+        settings: &KhmSettings,
+        operation_log: &mut Vec<String>,
+    ) {
+        // Handle auto-test on first frame if needed
+        if self.should_auto_test && !self.is_testing_connection {
+            self.should_auto_test = false;
+            self.start_test(settings, ctx);
+        }
        // Check for test connection result
        if let Some(receiver) = &self.test_result_receiver {
            if let Ok(result) = receiver.try_recv() {
@@ -112,25 +120,37 @@ impl ConnectionTab {
                        // Parse keys count from message
                        let keys_count = if let Some(start) = message.find("Found ") {
                            if let Some(end) = message[start + 6..].find(" SSH keys") {
-                                message[start + 6..start + 6 + end].parse::<usize>().unwrap_or(0)
-                            } else { 0 }
-                        } else { 0 };
+                                message[start + 6..start + 6 + end]
+                                    .parse::<usize>()
+                                    .unwrap_or(0)
+                            } else {
+                                0
+                            }
+                        } else {
+                            0
+                        };

                        self.connection_status = ConnectionStatus::Connected {
                            keys_count,
-                            flow: settings.flow.clone()
+                            flow: settings.flow.clone(),
                        };
                        info!("Connection test successful: {}", message);

                        // Add to UI log
-                        super::ui::add_log_entry(operation_log, format!("✅ Connection test successful: {}", message));
+                        super::ui::add_log_entry(
+                            operation_log,
+                            format!("✅ Connection test successful: {}", message),
+                        );
                    }
                    Err(error) => {
                        self.connection_status = ConnectionStatus::Error(error.clone());
                        error!("Connection test failed");

                        // Add to UI log
-                        super::ui::add_log_entry(operation_log, format!("❌ Connection test failed: {}", error));
+                        super::ui::add_log_entry(
+                            operation_log,
+                            format!("❌ Connection test failed: {}", error),
+                        );
                    }
                }
                self.test_result_receiver = None;
@@ -150,14 +170,20 @@ impl ConnectionTab {
                        info!("Sync successful: {}", message);

                        // Add to UI log
-                        super::ui::add_log_entry(operation_log, format!("✅ Sync completed: {}", message));
+                        super::ui::add_log_entry(
+                            operation_log,
+                            format!("✅ Sync completed: {}", message),
+                        );
                    }
                    Err(error) => {
                        self.sync_status = SyncStatus::Error(error.clone());
                        error!("Sync failed");

                        // Add to UI log
-                        super::ui::add_log_entry(operation_log, format!("❌ Sync failed: {}", error));
+                        super::ui::add_log_entry(
+                            operation_log,
+                            format!("❌ Sync failed: {}", error),
+                        );
                    }
                }
                self.sync_result_receiver = None;
--- a/src/gui/settings/ui.rs
+++ b/src/gui/settings/ui.rs
@@ -1,6 +1,6 @@
+use super::connection::{save_settings_validated, ConnectionStatus, ConnectionTab, SyncStatus};
+use crate::gui::common::{get_config_path, KhmSettings};
 use eframe::egui;
-use crate::gui::common::{KhmSettings, get_config_path};
-use super::connection::{ConnectionTab, ConnectionStatus, SyncStatus, save_settings_validated};

 /// Render connection settings tab with modern horizontal UI design
 pub fn render_connection_tab(
@@ -9,7 +9,7 @@ pub fn render_connection_tab(
    settings: &mut KhmSettings,
    auto_sync_interval_str: &mut String,
    connection_tab: &mut ConnectionTab,
-    operation_log: &mut Vec<String>
+    operation_log: &mut Vec<String>,
 ) {
    // Check for connection test and sync results
    connection_tab.check_results(ctx, settings, operation_log);
@@ -41,7 +41,7 @@ pub fn render_connection_tab(

                        // Local Configuration Card
                        render_local_config_card(ui, settings);
-                    }
+                    },
                );

                ui.add_space(8.0);
@@ -56,7 +56,7 @@ pub fn render_connection_tab(

                        // System Information Card
                        render_system_info_card(ui);
-                    }
+                    },
                );
            });

@@ -71,7 +71,10 @@ pub fn render_connection_tab(
 fn render_connection_status_card(ui: &mut egui::Ui, connection_tab: &ConnectionTab) {
    let frame = egui::Frame::group(ui.style())
        .fill(ui.visuals().faint_bg_color)
-        .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color))
+        .stroke(egui::Stroke::new(
+            1.0,
+            ui.visuals().widgets.noninteractive.bg_stroke.color,
+        ))
        .rounding(6.0)
        .inner_margin(egui::Margin::same(12.0));

@@ -85,11 +88,13 @@ fn render_connection_status_card(ui: &mut egui::Ui, connection_tab: &ConnectionT
                    } else {
                        format!("Connected to '{}' • {} keys", flow, keys_count)
                    };
-                    ("🟢", text, egui::Color32::GREEN)
-                }
-                ConnectionStatus::Error(error_msg) => {
-                    ("🔴", format!("Connection Error: {}", error_msg), egui::Color32::RED)
+                    ("✅", text, egui::Color32::GREEN)
                }
+                ConnectionStatus::Error(error_msg) => (
+                    "❌",
+                    format!("Connection Error: {}", error_msg),
+                    egui::Color32::RED,
+                ),
                ConnectionStatus::Unknown => {
                    ("⚫", "Not Connected".to_string(), ui.visuals().text_color())
                }
@@ -101,9 +106,17 @@ fn render_connection_status_card(ui: &mut egui::Ui, connection_tab: &ConnectionT
            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                if connection_tab.is_testing_connection {
                    ui.spinner();
-                    ui.label(egui::RichText::new("Testing...").italics().color(ui.visuals().weak_text_color()));
+                    ui.label(
+                        egui::RichText::new("Testing...")
+                            .italics()
+                            .color(ui.visuals().weak_text_color()),
+                    );
                } else {
-                    ui.label(egui::RichText::new(&status_text).size(13.0).color(status_color));
+                    ui.label(
+                        egui::RichText::new(&status_text)
+                            .size(13.0)
+                            .color(status_color),
+                    );
                }
            });
        });
@@ -119,17 +132,26 @@ fn render_connection_status_card(ui: &mut egui::Ui, connection_tab: &ConnectionT

            match &connection_tab.sync_status {
                SyncStatus::Success { keys_count } => {
-                    ui.label(egui::RichText::new(format!("✅ {} keys synced", keys_count))
-                        .size(13.0).color(egui::Color32::GREEN));
+                    ui.label(
+                        egui::RichText::new(format!("✅ {} keys synced", keys_count))
+                            .size(13.0)
+                            .color(egui::Color32::GREEN),
+                    );
                }
                SyncStatus::Error(error_msg) => {
-                    ui.label(egui::RichText::new("❌ Failed")
-                        .size(13.0).color(egui::Color32::RED))
-                        .on_hover_text(error_msg);
+                    ui.label(
+                        egui::RichText::new("❌ Failed")
+                            .size(13.0)
+                            .color(egui::Color32::RED),
+                    )
+                    .on_hover_text(error_msg);
                }
                SyncStatus::Unknown => {
-                    ui.label(egui::RichText::new("No sync performed yet")
-                        .size(13.0).color(ui.visuals().weak_text_color()));
+                    ui.label(
+                        egui::RichText::new("No sync performed yet")
+                            .size(13.0)
+                            .color(ui.visuals().weak_text_color()),
+                    );
                }
            }
        });
@@ -142,7 +164,10 @@ fn render_connection_status_card(ui: &mut egui::Ui, connection_tab: &ConnectionT
 fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings) {
    let frame = egui::Frame::group(ui.style())
        .fill(ui.visuals().faint_bg_color)
-        .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color))
+        .stroke(egui::Stroke::new(
+            1.0,
+            ui.visuals().widgets.noninteractive.bg_stroke.color,
+        ))
        .rounding(6.0)
        .inner_margin(egui::Margin::same(12.0));

@@ -150,7 +175,11 @@ fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings)
        // Header
        ui.horizontal(|ui| {
            ui.label("🌐");
-            ui.label(egui::RichText::new("Server Configuration").size(14.0).strong());
+            ui.label(
+                egui::RichText::new("Server Configuration")
+                    .size(14.0)
+                    .strong(),
+            );
        });

        ui.add_space(8.0);
@@ -168,7 +197,7 @@ fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings)
                    egui::TextEdit::singleline(&mut settings.host)
                        .hint_text("https://your-khm-server.com")
                        .font(egui::FontId::new(14.0, egui::FontFamily::Monospace))
-                        .margin(egui::Margin::symmetric(8.0, 6.0)) // Better vertical centering
+                        .margin(egui::Margin::symmetric(8.0, 6.0)), // Better vertical centering
                );
            });

@@ -181,15 +210,24 @@ fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings)
                    egui::TextEdit::singleline(&mut settings.flow)
                        .hint_text("production, staging, development")
                        .font(egui::FontId::new(14.0, egui::FontFamily::Proportional))
-                        .margin(egui::Margin::symmetric(8.0, 6.0))
+                        .margin(egui::Margin::symmetric(8.0, 6.0)),
                );
            });

            // Basic Auth (optional)
            ui.vertical(|ui| {
                ui.horizontal(|ui| {
-                    ui.label(egui::RichText::new("Basic Authentication").size(13.0).strong());
-                    ui.label(egui::RichText::new("(optional)").size(12.0).weak().italics());
+                    ui.label(
+                        egui::RichText::new("Basic Authentication")
+                            .size(13.0)
+                            .strong(),
+                    );
+                    ui.label(
+                        egui::RichText::new("(optional)")
+                            .size(12.0)
+                            .weak()
+                            .italics(),
+                    );
                });
                ui.add_space(3.0);
                ui.add_sized(
@@ -198,7 +236,7 @@ fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings)
                        .hint_text("username:password")
                        .password(true)
                        .font(egui::FontId::new(14.0, egui::FontFamily::Monospace))
-                        .margin(egui::Margin::symmetric(8.0, 6.0))
+                        .margin(egui::Margin::symmetric(8.0, 6.0)),
                );
            });
        });
@@ -211,7 +249,10 @@ fn render_connection_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings)
 fn render_local_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings) {
    let frame = egui::Frame::group(ui.style())
        .fill(ui.visuals().faint_bg_color)
-        .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color))
+        .stroke(egui::Stroke::new(
+            1.0,
+            ui.visuals().widgets.noninteractive.bg_stroke.color,
+        ))
        .rounding(6.0)
        .inner_margin(egui::Margin::same(12.0));

@@ -219,21 +260,29 @@ fn render_local_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings) {
        // Header
        ui.horizontal(|ui| {
            ui.label("📁");
-            ui.label(egui::RichText::new("Local Configuration").size(14.0).strong());
+            ui.label(
+                egui::RichText::new("Local Configuration")
+                    .size(14.0)
+                    .strong(),
+            );
        });

        ui.add_space(8.0);

        // Known hosts file
        ui.vertical(|ui| {
-            ui.label(egui::RichText::new("Known Hosts File Path").size(13.0).strong());
+            ui.label(
+                egui::RichText::new("Known Hosts File Path")
+                    .size(13.0)
+                    .strong(),
+            );
            ui.add_space(3.0);
            ui.add_sized(
                [ui.available_width(), 28.0],
                egui::TextEdit::singleline(&mut settings.known_hosts)
                    .hint_text("~/.ssh/known_hosts")
                    .font(egui::FontId::new(14.0, egui::FontFamily::Monospace))
-                    .margin(egui::Margin::symmetric(8.0, 6.0))
+                    .margin(egui::Margin::symmetric(8.0, 6.0)),
            );

            ui.add_space(8.0);
@@ -242,8 +291,19 @@ fn render_local_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings) {
            ui.horizontal(|ui| {
                ui.checkbox(&mut settings.in_place, "");
                ui.vertical(|ui| {
-                    ui.label(egui::RichText::new("Update file in-place after sync").size(13.0).strong());
-                    ui.label(egui::RichText::new("Automatically modify the known_hosts file when synchronizing").size(12.0).weak().italics());
+                    ui.label(
+                        egui::RichText::new("Update file in-place after sync")
+                            .size(13.0)
+                            .strong(),
+                    );
+                    ui.label(
+                        egui::RichText::new(
+                            "Automatically modify the known_hosts file when synchronizing",
+                        )
+                        .size(12.0)
+                        .weak()
+                        .italics(),
+                    );
                });
            });
        });
@@ -253,17 +313,23 @@ fn render_local_config_card(ui: &mut egui::Ui, settings: &mut KhmSettings) {
 }

 /// Auto-sync configuration card
-fn render_auto_sync_card(ui: &mut egui::Ui, settings: &mut KhmSettings, auto_sync_interval_str: &mut String) {
+fn render_auto_sync_card(
+    ui: &mut egui::Ui,
+    settings: &mut KhmSettings,
+    auto_sync_interval_str: &mut String,
+) {
    let frame = egui::Frame::group(ui.style())
        .fill(ui.visuals().faint_bg_color)
-        .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color))
+        .stroke(egui::Stroke::new(
+            1.0,
+            ui.visuals().widgets.noninteractive.bg_stroke.color,
+        ))
        .rounding(6.0)
        .inner_margin(egui::Margin::same(12.0));

    frame.show(ui, |ui| {
-        let is_auto_sync_enabled = !settings.host.is_empty() 
-            && !settings.flow.is_empty() 
-            && settings.in_place;
+        let is_auto_sync_enabled =
+            !settings.host.is_empty() && !settings.flow.is_empty() && settings.in_place;

        // Header with status
        ui.horizontal(|ui| {
@@ -272,12 +338,16 @@ fn render_auto_sync_card(ui: &mut egui::Ui, settings: &mut KhmSettings, auto_syn

            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                let (status_text, status_color) = if is_auto_sync_enabled {
-                    ("● Active", egui::Color32::GREEN)
+                    ("✅ Active", egui::Color32::GREEN)
                } else {
-                    ("○ Inactive", egui::Color32::from_gray(128))
+                    ("❌ Inactive", egui::Color32::from_gray(128))
                };

-                ui.label(egui::RichText::new(status_text).size(12.0).color(status_color));
+                ui.label(
+                    egui::RichText::new(status_text)
+                        .size(12.0)
+                        .color(status_color),
+                );
            });
        });

@@ -288,11 +358,11 @@ fn render_auto_sync_card(ui: &mut egui::Ui, settings: &mut KhmSettings, auto_syn
            ui.label(egui::RichText::new("Interval").size(13.0).strong());
            ui.add_space(6.0);
            ui.add_sized(
-            [80.0, 26.0], // Smaller height
-            egui::TextEdit::singleline(auto_sync_interval_str)
-            .font(egui::FontId::new(14.0, egui::FontFamily::Monospace))
-                    .margin(egui::Margin::symmetric(6.0, 5.0))
-        );
+                [80.0, 26.0], // Smaller height
+                egui::TextEdit::singleline(auto_sync_interval_str)
+                    .font(egui::FontId::new(14.0, egui::FontFamily::Monospace))
+                    .margin(egui::Margin::symmetric(6.0, 5.0)),
+            );
            ui.label("min");

            // Update the actual setting
@@ -317,19 +387,31 @@ fn render_auto_sync_card(ui: &mut egui::Ui, settings: &mut KhmSettings, auto_syn
            let in_place_ok = settings.in_place;

            ui.horizontal(|ui| {
-                let (icon, color) = if host_ok { ("✅", egui::Color32::GREEN) } else { ("❌", egui::Color32::RED) };
+                let (icon, color) = if host_ok {
+                    ("✅", egui::Color32::GREEN)
+                } else {
+                    ("❌", egui::Color32::RED)
+                };
                ui.label(egui::RichText::new(icon).color(color));
                ui.label(egui::RichText::new("Host URL").size(11.0));
            });

            ui.horizontal(|ui| {
-                let (icon, color) = if flow_ok { ("✅", egui::Color32::GREEN) } else { ("❌", egui::Color32::RED) };
+                let (icon, color) = if flow_ok {
+                    ("✅", egui::Color32::GREEN)
+                } else {
+                    ("❌", egui::Color32::RED)
+                };
                ui.label(egui::RichText::new(icon).color(color));
                ui.label(egui::RichText::new("Flow name").size(11.0));
            });

            ui.horizontal(|ui| {
-                let (icon, color) = if in_place_ok { ("✅", egui::Color32::GREEN) } else { ("❌", egui::Color32::RED) };
+                let (icon, color) = if in_place_ok {
+                    ("✅", egui::Color32::GREEN)
+                } else {
+                    ("❌", egui::Color32::RED)
+                };
                ui.label(egui::RichText::new(icon).color(color));
                ui.label(egui::RichText::new("In-place update").size(11.0));
            });
@@ -343,14 +425,17 @@ fn render_auto_sync_card(ui: &mut egui::Ui, settings: &mut KhmSettings, auto_syn
 fn render_system_info_card(ui: &mut egui::Ui) {
    let frame = egui::Frame::group(ui.style())
        .fill(ui.visuals().extreme_bg_color)
-        .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color))
+        .stroke(egui::Stroke::new(
+            1.0,
+            ui.visuals().widgets.noninteractive.bg_stroke.color,
+        ))
        .rounding(6.0)
        .inner_margin(egui::Margin::same(12.0));

    frame.show(ui, |ui| {
        // Header
        ui.horizontal(|ui| {
-            ui.label("⚙️");
+            ui.label("🔧");
            ui.label(egui::RichText::new("System Info").size(14.0).strong());
        });

@@ -366,12 +451,12 @@ fn render_system_info_card(ui: &mut egui::Ui) {

            ui.vertical(|ui| {
                ui.add_sized(
-                [ui.available_width(), 26.0], // Smaller height
-                egui::TextEdit::singleline(&mut path_str.clone())
-                .interactive(false)
-                .font(egui::FontId::new(12.0, egui::FontFamily::Monospace))
-                        .margin(egui::Margin::symmetric(8.0, 5.0))
-        );
+                    [ui.available_width(), 26.0], // Smaller height
+                    egui::TextEdit::singleline(&mut path_str.clone())
+                        .interactive(false)
+                        .font(egui::FontId::new(12.0, egui::FontFamily::Monospace))
+                        .margin(egui::Margin::symmetric(8.0, 5.0)),
+                );

                ui.add_space(4.0);

@@ -391,25 +476,22 @@ fn render_action_section(
    ctx: &egui::Context,
    settings: &KhmSettings,
    connection_tab: &mut ConnectionTab,
-    operation_log: &mut Vec<String>
+    operation_log: &mut Vec<String>,
 ) {
-    ui.add_space(8.0);
+    ui.add_space(2.0);

-    // Validation message
+    // Validation for save button
    let save_enabled = !settings.host.is_empty() && !settings.flow.is_empty();
-    if !save_enabled {
-        ui.horizontal(|ui| {
-            ui.label("⚠️");
-            ui.label(egui::RichText::new("Complete server configuration to enable saving")
-                .size(12.0)
-                .color(egui::Color32::LIGHT_YELLOW)
-                .italics());
-        });
-        ui.add_space(8.0);
-    }

    // Action buttons with modern styling
-    render_modern_action_buttons(ui, ctx, settings, connection_tab, save_enabled, operation_log);
+    render_modern_action_buttons(
+        ui,
+        ctx,
+        settings,
+        connection_tab,
+        save_enabled,
+        operation_log,
+    );
 }

 /// Modern action buttons with improved styling and layout
@@ -419,13 +501,13 @@ fn render_modern_action_buttons(
    settings: &KhmSettings,
    connection_tab: &mut ConnectionTab,
    save_enabled: bool,
-    operation_log: &mut Vec<String>
+    operation_log: &mut Vec<String>,
 ) {
    ui.horizontal(|ui| {
        ui.spacing_mut().item_spacing.x = 8.0;

        // Primary actions (left side)
-        if ui.add_enabled(
+        let mut save_button = ui.add_enabled(
            save_enabled,
            egui::Button::new(
                egui::RichText::new("💾 Save & Close")
@@ -439,7 +521,14 @@ fn render_modern_action_buttons(
            })
            .min_size(egui::vec2(120.0, 32.0))
            .rounding(6.0)
-        ).clicked() {
+        );
+
+        // Add tooltip when button is disabled
+        if !save_enabled {
+            save_button = save_button.on_hover_text("Complete server configuration to enable saving:\n• Host URL is required\n• Flow name is required");
+        }
+
+        if save_button.clicked() {
            match save_settings_validated(settings) {
                Ok(()) => {
                    add_log_entry(operation_log, "✅ Settings saved successfully".to_string());
--- a/src/gui/settings/window.rs
+++ b/src/gui/settings/window.rs
@@ -1,14 +1,17 @@
+use crate::gui::admin::{
+    render_bulk_actions, render_keys_table, render_search_controls, render_statistics,
+    AdminOperation, AdminState, BulkAction, KeyAction,
+};
+use crate::gui::api::{
+    bulk_deprecate_servers, bulk_restore_servers, delete_key, deprecate_key, restore_key, SshKey,
+};
+use crate::gui::common::{load_settings, KhmSettings};
 use eframe::egui;
 use log::info;
 use std::sync::mpsc;
-use crate::gui::common::{load_settings, KhmSettings};
-use crate::gui::admin::{AdminState, AdminOperation, render_statistics, render_search_controls, 
-                      render_bulk_actions, render_keys_table, KeyAction, BulkAction};
-use crate::gui::api::{SshKey, bulk_deprecate_servers, bulk_restore_servers, 
-                     deprecate_key, restore_key, delete_key};

 use super::connection::{ConnectionTab, SettingsTab};
-use super::ui::{render_connection_tab, add_log_entry};
+use super::ui::{add_log_entry, render_connection_tab};

 pub struct SettingsWindow {
    settings: KhmSettings,
@@ -26,7 +29,7 @@ impl SettingsWindow {
        let settings = load_settings();
        let auto_sync_interval_str = settings.auto_sync_interval_minutes.to_string();

-        Self {
+        let mut instance = Self {
            settings,
            auto_sync_interval_str,
            current_tab: SettingsTab::Connection,
@@ -35,7 +38,20 @@ impl SettingsWindow {
            admin_receiver: None,
            operation_receiver: None,
            operation_log: Vec::new(),
+        };
+
+        // Auto-test connection if configuration is found and valid
+        if !instance.settings.host.is_empty() && !instance.settings.flow.is_empty() {
+            add_log_entry(
+                &mut instance.operation_log,
+                "🔍 Auto-testing connection with saved configuration...".to_string(),
+            );
+            // We can't call start_test here because we don't have egui::Context yet
+            // So we set a flag to trigger test on first frame
+            instance.connection_tab.should_auto_test = true;
        }
+
+        instance
    }
 }

@@ -52,18 +68,20 @@ impl eframe::App for SettingsWindow {
            .resizable(false)
            .min_height(140.0)
            .max_height(140.0)
-            .frame(egui::Frame::none()
-                .fill(egui::Color32::from_gray(12))
-                .stroke(egui::Stroke::new(1.0, egui::Color32::from_gray(60)))
+            .frame(
+                egui::Frame::none()
+                    .fill(egui::Color32::from_gray(12))
+                    .stroke(egui::Stroke::new(1.0, egui::Color32::from_gray(60))),
            )
            .show(ctx, |ui| {
                render_bottom_activity_log(ui, &mut self.operation_log);
            });

        egui::CentralPanel::default()
-            .frame(egui::Frame::none()
-                .fill(egui::Color32::from_gray(18))
-                .inner_margin(egui::Margin::same(20.0))
+            .frame(
+                egui::Frame::none()
+                    .fill(egui::Color32::from_gray(18))
+                    .inner_margin(egui::Margin::same(20.0)),
            )
            .show(ctx, |ui| {
                // Modern header with gradient-like styling
@@ -71,21 +89,30 @@ impl eframe::App for SettingsWindow {
                    .fill(ui.visuals().panel_fill)
                    .rounding(egui::Rounding::same(8.0))
                    .inner_margin(egui::Margin::same(12.0))
-                    .stroke(egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color));
+                    .stroke(egui::Stroke::new(
+                        1.0,
+                        ui.visuals().widgets.noninteractive.bg_stroke.color,
+                    ));

                header_frame.show(ui, |ui| {
                    ui.horizontal(|ui| {
                        ui.add_space(4.0);
                        ui.label("🔑");
                        ui.heading(egui::RichText::new("KHM Settings").size(20.0).strong());
-                        ui.label(egui::RichText::new(
-                            "(Known Hosts Manager for SSH key management and synchronization)"
-                        ).size(11.0).weak().italics());
+                        ui.label(
+                            egui::RichText::new(
+                                "(Known Hosts Manager for SSH key management and synchronization)",
+                            )
+                            .size(11.0)
+                            .weak()
+                            .italics(),
+                        );

                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                            // Version from Cargo.toml
                            let version = env!("CARGO_PKG_VERSION");
-                            if ui.small_button(format!("v{}", version))
+                            if ui
+                                .small_button(format!("v{}", version))
                                .on_hover_text(format!(
                                    "{}\n{}\nRepository: {}\nLicense: {}",
                                    env!("CARGO_PKG_DESCRIPTION"),
@@ -118,21 +145,23 @@ impl eframe::App for SettingsWindow {

                    // Connection/Settings Tab
                    let connection_selected = matches!(self.current_tab, SettingsTab::Connection);
-                    let connection_button = egui::Button::new(
-                        egui::RichText::new("🌐 Connection").size(13.0)
-                    )
-                    .fill(if connection_selected { 
-                        egui::Color32::from_rgb(0, 120, 212)
-                    } else {
-                        ui.visuals().widgets.inactive.bg_fill
-                    })
-                    .stroke(if connection_selected {
-                        egui::Stroke::new(1.0, egui::Color32::from_rgb(0, 120, 212))
-                    } else {
-                        egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color)
-                    })
-                    .rounding(6.0)
-                    .min_size(egui::vec2(110.0, 32.0));
+                    let connection_button =
+                        egui::Button::new(egui::RichText::new("🌐 Connection").size(13.0))
+                            .fill(if connection_selected {
+                                egui::Color32::from_rgb(0, 120, 212)
+                            } else {
+                                ui.visuals().widgets.inactive.bg_fill
+                            })
+                            .stroke(if connection_selected {
+                                egui::Stroke::new(1.0, egui::Color32::from_rgb(0, 120, 212))
+                            } else {
+                                egui::Stroke::new(
+                                    1.0,
+                                    ui.visuals().widgets.noninteractive.bg_stroke.color,
+                                )
+                            })
+                            .rounding(6.0)
+                            .min_size(egui::vec2(110.0, 32.0));

                    if ui.add(connection_button).clicked() {
                        self.current_tab = SettingsTab::Connection;
@@ -140,21 +169,23 @@ impl eframe::App for SettingsWindow {

                    // Admin Tab
                    let admin_selected = matches!(self.current_tab, SettingsTab::Admin);
-                    let admin_button = egui::Button::new(
-                        egui::RichText::new("🔧 Admin Panel").size(13.0)
-                    )
-                    .fill(if admin_selected { 
-                        egui::Color32::from_rgb(120, 80, 0)
-                    } else {
-                        ui.visuals().widgets.inactive.bg_fill
-                    })
-                    .stroke(if admin_selected {
-                        egui::Stroke::new(1.0, egui::Color32::from_rgb(120, 80, 0))
-                    } else {
-                        egui::Stroke::new(1.0, ui.visuals().widgets.noninteractive.bg_stroke.color)
-                    })
-                    .rounding(6.0)
-                    .min_size(egui::vec2(110.0, 32.0));
+                    let admin_button =
+                        egui::Button::new(egui::RichText::new("🔧 Admin Panel").size(13.0))
+                            .fill(if admin_selected {
+                                egui::Color32::from_rgb(120, 80, 0)
+                            } else {
+                                ui.visuals().widgets.inactive.bg_fill
+                            })
+                            .stroke(if admin_selected {
+                                egui::Stroke::new(1.0, egui::Color32::from_rgb(120, 80, 0))
+                            } else {
+                                egui::Stroke::new(
+                                    1.0,
+                                    ui.visuals().widgets.noninteractive.bg_stroke.color,
+                                )
+                            })
+                            .rounding(6.0)
+                            .min_size(egui::vec2(110.0, 32.0));

                    if ui.add(admin_button).clicked() {
                        self.current_tab = SettingsTab::Admin;
@@ -172,7 +203,7 @@ impl eframe::App for SettingsWindow {
                            &mut self.settings,
                            &mut self.auto_sync_interval_str,
                            &mut self.connection_tab,
-                            &mut self.operation_log
+                            &mut self.operation_log,
                        );
                    }
                    SettingsTab::Admin => {
@@ -205,7 +236,10 @@ impl SettingsWindow {
                        self.load_admin_keys(ctx);
                    }
                    Err(error) => {
-                        add_log_entry(&mut self.operation_log, format!("❌ Operation failed: {}", error));
+                        add_log_entry(
+                            &mut self.operation_log,
+                            format!("❌ Operation failed: {}", error),
+                        );
                    }
                }
                self.admin_state.current_operation = AdminOperation::None;
@@ -238,9 +272,11 @@ impl SettingsWindow {
        // Check if connection is configured
        if self.settings.host.is_empty() || self.settings.flow.is_empty() {
            ui.vertical_centered(|ui| {
-                ui.label(egui::RichText::new("❗ Please configure connection settings first")
-                    .size(16.0)
-                    .color(egui::Color32::YELLOW));
+                ui.label(
+                    egui::RichText::new("❗ Please configure connection settings first")
+                        .size(16.0)
+                        .color(egui::Color32::YELLOW),
+                );
                ui.add_space(10.0);
                if ui.button("Go to Connection Settings").clicked() {
                    self.current_tab = SettingsTab::Connection;
@@ -250,12 +286,20 @@ impl SettingsWindow {
        }

        // Load keys automatically on first view
-        if self.admin_state.keys.is_empty() && !matches!(self.admin_state.current_operation, AdminOperation::LoadingKeys) {
+        if self.admin_state.keys.is_empty()
+            && !matches!(
+                self.admin_state.current_operation,
+                AdminOperation::LoadingKeys
+            )
+        {
            self.load_admin_keys(ctx);
        }

        // Show loading state
-        if matches!(self.admin_state.current_operation, AdminOperation::LoadingKeys) {
+        if matches!(
+            self.admin_state.current_operation,
+            AdminOperation::LoadingKeys
+        ) {
            ui.vertical_centered(|ui| {
                ui.spinner();
                ui.label("Loading keys...");
@@ -333,7 +377,10 @@ impl SettingsWindow {

    fn start_bulk_deprecate(&mut self, servers: Vec<String>, ctx: &egui::Context) {
        self.admin_state.current_operation = AdminOperation::BulkDeprecating;
-        add_log_entry(&mut self.operation_log, format!("Deprecating {} servers...", servers.len()));
+        add_log_entry(
+            &mut self.operation_log,
+            format!("Deprecating {} servers...", servers.len()),
+        );

        let (tx, rx) = mpsc::channel();
        self.operation_receiver = Some(rx);
@@ -345,9 +392,8 @@ impl SettingsWindow {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                bulk_deprecate_servers(host, flow, basic_auth, servers).await
-            });
+            let result = rt
+                .block_on(async { bulk_deprecate_servers(host, flow, basic_auth, servers).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -356,7 +402,10 @@ impl SettingsWindow {

    fn start_bulk_restore(&mut self, servers: Vec<String>, ctx: &egui::Context) {
        self.admin_state.current_operation = AdminOperation::BulkRestoring;
-        add_log_entry(&mut self.operation_log, format!("Restoring {} servers...", servers.len()));
+        add_log_entry(
+            &mut self.operation_log,
+            format!("Restoring {} servers...", servers.len()),
+        );

        let (tx, rx) = mpsc::channel();
        self.operation_receiver = Some(rx);
@@ -368,9 +417,8 @@ impl SettingsWindow {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                bulk_restore_servers(host, flow, basic_auth, servers).await
-            });
+            let result =
+                rt.block_on(async { bulk_restore_servers(host, flow, basic_auth, servers).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -379,7 +427,10 @@ impl SettingsWindow {

    fn start_deprecate_key(&mut self, server: &str, ctx: &egui::Context) {
        self.admin_state.current_operation = AdminOperation::DeprecatingKey;
-        add_log_entry(&mut self.operation_log, format!("Deprecating key for server: {}", server));
+        add_log_entry(
+            &mut self.operation_log,
+            format!("Deprecating key for server: {}", server),
+        );

        let (tx, rx) = mpsc::channel();
        self.operation_receiver = Some(rx);
@@ -392,9 +443,8 @@ impl SettingsWindow {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                deprecate_key(host, flow, basic_auth, server_name).await
-            });
+            let result =
+                rt.block_on(async { deprecate_key(host, flow, basic_auth, server_name).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -403,7 +453,10 @@ impl SettingsWindow {

    fn start_restore_key(&mut self, server: &str, ctx: &egui::Context) {
        self.admin_state.current_operation = AdminOperation::RestoringKey;
-        add_log_entry(&mut self.operation_log, format!("Restoring key for server: {}", server));
+        add_log_entry(
+            &mut self.operation_log,
+            format!("Restoring key for server: {}", server),
+        );

        let (tx, rx) = mpsc::channel();
        self.operation_receiver = Some(rx);
@@ -416,9 +469,8 @@ impl SettingsWindow {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                restore_key(host, flow, basic_auth, server_name).await
-            });
+            let result =
+                rt.block_on(async { restore_key(host, flow, basic_auth, server_name).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -427,7 +479,10 @@ impl SettingsWindow {

    fn start_delete_key(&mut self, server: &str, ctx: &egui::Context) {
        self.admin_state.current_operation = AdminOperation::DeletingKey;
-        add_log_entry(&mut self.operation_log, format!("Deleting key for server: {}", server));
+        add_log_entry(
+            &mut self.operation_log,
+            format!("Deleting key for server: {}", server),
+        );

        let (tx, rx) = mpsc::channel();
        self.operation_receiver = Some(rx);
@@ -440,9 +495,8 @@ impl SettingsWindow {

        std::thread::spawn(move || {
            let rt = tokio::runtime::Runtime::new().unwrap();
-            let result = rt.block_on(async {
-                delete_key(host, flow, basic_auth, server_name).await
-            });
+            let result =
+                rt.block_on(async { delete_key(host, flow, basic_auth, server_name).await });

            let _ = tx.send(result);
            ctx_clone.request_repaint();
@@ -455,8 +509,8 @@ fn apply_modern_theme(ctx: &egui::Context) {
    let mut visuals = egui::Visuals::dark();

    // Modern color palette
-    visuals.window_fill = egui::Color32::from_gray(18);  // Darker background
-    visuals.panel_fill = egui::Color32::from_gray(24);   // Panel background
+    visuals.window_fill = egui::Color32::from_gray(18); // Darker background
+    visuals.panel_fill = egui::Color32::from_gray(24); // Panel background
    visuals.faint_bg_color = egui::Color32::from_gray(32); // Card background
    visuals.extreme_bg_color = egui::Color32::from_gray(12); // Darkest areas

@@ -530,7 +584,7 @@ fn render_bottom_activity_log(ui: &mut egui::Ui, operation_log: &mut Vec<String>
            [ui.available_width() - 8.0, 80.0], // Account for right margin
            egui::TextEdit::multiline(&mut log_text.clone())
                .font(egui::FontId::new(11.0, egui::FontFamily::Monospace))
-                .interactive(false)
+                .interactive(false),
        );

        ui.add_space(8.0); // Right margin
@@ -565,8 +619,8 @@ pub fn run_settings_window() {
    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default()
            .with_title("KHM Settings")
-            .with_inner_size([900.0, 905.0])  // Decreased height by another 15px
-            .with_min_inner_size([900.0, 905.0])  // Fixed size
+            .with_inner_size([900.0, 905.0]) // Decreased height by another 15px
+            .with_min_inner_size([900.0, 905.0]) // Fixed size
            .with_max_inner_size([900.0, 905.0]) // Same as min - fixed size
            .with_resizable(false) // Disable resizing since window is fixed size
            .with_icon(create_window_icon())
--- a/src/gui/tray/app.rs
+++ b/src/gui/tray/app.rs
@@ -6,10 +6,7 @@ use notify::RecursiveMode;
 use notify_debouncer_mini::{new_debouncer, DebounceEventResult};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use tray_icon::{
-    menu::MenuEvent,
-    TrayIcon,
-};
+use tray_icon::{menu::MenuEvent, TrayIcon};
 use winit::{
    application::ApplicationHandler,
    event_loop::{EventLoop, EventLoopProxy},
@@ -18,12 +15,52 @@ use winit::{
 #[cfg(target_os = "macos")]
 use winit::platform::macos::EventLoopBuilderExtMacOS;

-use super::{SyncStatus, TrayMenuIds, create_tray_icon, update_tray_menu, 
-             create_tooltip, start_auto_sync_task, update_sync_status};
-use crate::gui::common::{load_settings, get_config_path, perform_sync, KhmSettings};
+#[cfg(target_os = "linux")]
+use gtk::glib;
+
+// Channel for Linux tray communication
+
+#[cfg(target_os = "linux")]
+enum LinuxTrayCommand {
+    CreateTray {
+        settings: KhmSettings,
+        sync_status: SyncStatus,
+    },
+    UpdateMenu {
+        settings: KhmSettings,
+    },
+    SetTooltip {
+        tooltip: String,
+    },
+    #[allow(dead_code)]
+    Quit,
+}
+
+#[cfg(target_os = "linux")]
+enum LinuxTrayResponse {
+    TrayCreated {
+        menu_ids: TrayMenuIds,
+    },
+    #[allow(dead_code)]
+    MenuUpdated {
+        menu_ids: TrayMenuIds,
+    },
+    Error(String),
+}
+
+use super::{
+    create_tooltip, create_tray_icon, start_auto_sync_task, update_sync_status, update_tray_menu,
+    SyncStatus, TrayMenuIds,
+};
+use crate::gui::common::{get_config_path, load_settings, perform_sync, KhmSettings};

 pub struct TrayApplication {
+    #[cfg(not(target_os = "linux"))]
    tray_icon: Option<TrayIcon>,
+    #[cfg(target_os = "linux")]
+    linux_tray_tx: Option<std::sync::mpsc::Sender<LinuxTrayCommand>>,
+    #[cfg(target_os = "linux")]
+    linux_tray_handle: Option<std::thread::JoinHandle<()>>,
    menu_ids: Option<TrayMenuIds>,
    settings: Arc<Mutex<KhmSettings>>,
    sync_status: Arc<Mutex<SyncStatus>>,
@@ -36,7 +73,12 @@ pub struct TrayApplication {
 impl TrayApplication {
    pub fn new(proxy: EventLoopProxy<crate::gui::UserEvent>) -> Self {
        Self {
+            #[cfg(not(target_os = "linux"))]
            tray_icon: None,
+            #[cfg(target_os = "linux")]
+            linux_tray_tx: None,
+            #[cfg(target_os = "linux")]
+            linux_tray_handle: None,
            menu_ids: None,
            settings: Arc::new(Mutex::new(load_settings())),
            sync_status: Arc::new(Mutex::new(SyncStatus::default())),
@@ -56,7 +98,10 @@ impl TrayApplication {
        std::thread::spawn(move || {
            while let Ok(result) = rx.recv() {
                if let Ok(events) = result {
-                    if events.iter().any(|e| e.path.to_string_lossy().contains("khm_config.json")) {
+                    if events
+                        .iter()
+                        .any(|e| e.path.to_string_lossy().contains("khm_config.json"))
+                    {
                        let _ = proxy.send_event(crate::gui::UserEvent::ConfigFileChanged);
                    }
                }
@@ -65,7 +110,11 @@ impl TrayApplication {

        if let Ok(mut debouncer) = new_debouncer(Duration::from_millis(500), tx) {
            if let Some(config_dir) = config_path.parent() {
-                if debouncer.watcher().watch(config_dir, RecursiveMode::NonRecursive).is_ok() {
+                if debouncer
+                    .watcher()
+                    .watch(config_dir, RecursiveMode::NonRecursive)
+                    .is_ok()
+                {
                    info!("File watcher started");
                    self._debouncer = Some(debouncer);
                } else {
@@ -84,18 +133,28 @@ impl TrayApplication {
        *self.settings.lock().unwrap() = new_settings;

        // Update menu
+        #[cfg(not(target_os = "linux"))]
        if let Some(tray_icon) = &self.tray_icon {
            let settings = self.settings.lock().unwrap();
            let new_menu_ids = update_tray_menu(tray_icon, &settings);
            self.menu_ids = Some(new_menu_ids);
        }
        
+        #[cfg(target_os = "linux")]
+        if let Some(ref tx) = self.linux_tray_tx {
+            let settings = self.settings.lock().unwrap().clone();
+            let _ = tx.send(LinuxTrayCommand::UpdateMenu { settings });
+        }
+
        // Update tooltip
        self.update_tooltip();

        // Restart auto sync if interval changed
        if old_interval != new_interval {
-            info!("Auto sync interval changed from {} to {} minutes, restarting auto sync", old_interval, new_interval);
+            info!(
+                "Auto sync interval changed from {} to {} minutes, restarting auto sync",
+                old_interval, new_interval
+            );
            self.start_auto_sync();
        }
    }
@@ -109,20 +168,31 @@ impl TrayApplication {
        self.auto_sync_handle = start_auto_sync_task(
            Arc::clone(&self.settings),
            Arc::clone(&self.sync_status),
-            self.proxy.clone()
+            self.proxy.clone(),
        );
    }

    fn update_tooltip(&self) {
+        let settings = self.settings.lock().unwrap();
+        let sync_status = self.sync_status.lock().unwrap();
+        let tooltip = create_tooltip(&settings, &sync_status);
+        
+        #[cfg(not(target_os = "linux"))]
        if let Some(tray_icon) = &self.tray_icon {
-            let settings = self.settings.lock().unwrap();
-            let sync_status = self.sync_status.lock().unwrap();
-            let tooltip = create_tooltip(&settings, &sync_status);
            let _ = tray_icon.set_tooltip(Some(&tooltip));
        }
+        
+        #[cfg(target_os = "linux")]
+        if let Some(ref tx) = self.linux_tray_tx {
+            let _ = tx.send(LinuxTrayCommand::SetTooltip { tooltip });
+        }
    }

-    fn handle_menu_event(&mut self, event: MenuEvent, event_loop: &winit::event_loop::ActiveEventLoop) {
+    fn handle_menu_event(
+        &mut self,
+        event: MenuEvent,
+        event_loop: &winit::event_loop::ActiveEventLoop,
+    ) {
        if let Some(menu_ids) = &self.menu_ids {
            if event.id == menu_ids.settings_id {
                info!("Settings menu clicked");
@@ -141,7 +211,6 @@ impl TrayApplication {
        if let Ok(exe_path) = std::env::current_exe() {
            std::thread::spawn(move || {
                if let Err(e) = std::process::Command::new(&exe_path)
-                    .arg("--gui")
                    .arg("--settings-ui")
                    .spawn()
                {
@@ -162,7 +231,10 @@ impl TrayApplication {
            return;
        }

-        info!("Syncing with host: {}, flow: {}", settings.host, settings.flow);
+        info!(
+            "Syncing with host: {}, flow: {}",
+            settings.host, settings.flow
+        );

        // Run sync in separate thread with its own tokio runtime
        std::thread::spawn(move || {
@@ -202,27 +274,141 @@ impl ApplicationHandler<crate::gui::UserEvent> for TrayApplication {
        _event_loop: &winit::event_loop::ActiveEventLoop,
        _window_id: winit::window::WindowId,
        _event: winit::event::WindowEvent,
-    ) {}
+    ) {
+    }

    fn resumed(&mut self, _event_loop: &winit::event_loop::ActiveEventLoop) {
+        #[cfg(not(target_os = "linux"))]
        if self.tray_icon.is_none() {
            info!("Creating tray icon");
            let settings = self.settings.lock().unwrap();
            let sync_status = self.sync_status.lock().unwrap();
-            let (tray_icon, menu_ids) = create_tray_icon(&settings, &sync_status);
-            drop(settings);
-            drop(sync_status);
            
-            self.tray_icon = Some(tray_icon);
-            self.menu_ids = Some(menu_ids);
+            match std::panic::catch_unwind(|| create_tray_icon(&settings, &sync_status)) {
+                Ok((tray_icon, menu_ids)) => {
+                    drop(settings);
+                    drop(sync_status);

-            self.setup_file_watcher();
-            self.start_auto_sync();
-            info!("KHM tray application ready");
+                    self.tray_icon = Some(tray_icon);
+                    self.menu_ids = Some(menu_ids);
+
+                    self.setup_file_watcher();
+                    self.start_auto_sync();
+                    info!("KHM tray application ready");
+                }
+                Err(_) => {
+                    drop(settings);
+                    drop(sync_status);
+                    error!("Failed to create tray icon. This usually means the required system libraries are not installed.");
+                    error!("KHM will exit as system tray integration is required for desktop mode.");
+                    std::process::exit(1);
+                }
+            }
+        }
+        
+        #[cfg(target_os = "linux")]
+        if self.linux_tray_tx.is_none() {
+            info!("Creating tray icon on Linux");
+            
+            let (tx, rx) = std::sync::mpsc::channel();
+            let (response_tx, response_rx) = std::sync::mpsc::channel();
+            self.linux_tray_tx = Some(tx.clone());
+            
+            let proxy = self.proxy.clone();
+            
+            // Spawn GTK thread for tray
+            let handle = std::thread::spawn(move || {
+                if let Err(e) = gtk::init() {
+                    error!("Failed to initialize GTK: {}", e);
+                    let _ = response_tx.send(LinuxTrayResponse::Error(format!("GTK init failed: {}", e)));
+                    return;
+                }
+                
+                let mut tray_icon: Option<TrayIcon> = None;
+                
+                // Set up GTK event handlers
+                let _tx_clone = tx.clone();
+                glib::timeout_add_local(std::time::Duration::from_millis(100), move || {
+                    while let Ok(cmd) = rx.try_recv() {
+                        match cmd {
+                            LinuxTrayCommand::CreateTray { settings, sync_status } => {
+                                match std::panic::catch_unwind(|| create_tray_icon(&settings, &sync_status)) {
+                                    Ok((icon, menu_ids)) => {
+                                        tray_icon = Some(icon);
+                                        let _ = response_tx.send(LinuxTrayResponse::TrayCreated { menu_ids });
+                                    }
+                                    Err(_) => {
+                                        let _ = response_tx.send(LinuxTrayResponse::Error("Failed to create tray".to_string()));
+                                    }
+                                }
+                            }
+                            LinuxTrayCommand::UpdateMenu { settings } => {
+                                if let Some(ref icon) = tray_icon {
+                                    let menu_ids = update_tray_menu(icon, &settings);
+                                    let _ = response_tx.send(LinuxTrayResponse::MenuUpdated { menu_ids });
+                                }
+                            }
+                            LinuxTrayCommand::SetTooltip { tooltip } => {
+                                if let Some(ref icon) = tray_icon {
+                                    let _ = icon.set_tooltip(Some(&tooltip));
+                                }
+                            }
+                            LinuxTrayCommand::Quit => {
+                                gtk::main_quit();
+                                return glib::ControlFlow::Break;
+                            }
+                        }
+                    }
+                    
+                    // Check for menu events
+                    if let Ok(event) = MenuEvent::receiver().try_recv() {
+                        let _ = proxy.send_event(crate::gui::UserEvent::MenuEvent(event));
+                    }
+                    
+                    glib::ControlFlow::Continue
+                });
+                
+                gtk::main();
+            });
+            
+            self.linux_tray_handle = Some(handle);
+            
+            // Send command to create tray
+            let settings = self.settings.lock().unwrap().clone();
+            let sync_status = self.sync_status.lock().unwrap().clone();
+            
+            if let Some(ref tx) = self.linux_tray_tx {
+                let _ = tx.send(LinuxTrayCommand::CreateTray { settings, sync_status });
+                
+                // Wait for response
+                match response_rx.recv_timeout(std::time::Duration::from_secs(5)) {
+                    Ok(LinuxTrayResponse::TrayCreated { menu_ids }) => {
+                        self.menu_ids = Some(menu_ids);
+                        self.setup_file_watcher();
+                        self.start_auto_sync();
+                        info!("KHM tray application ready");
+                    }
+                    Ok(LinuxTrayResponse::Error(e)) => {
+                        error!("Failed to create tray icon: {}", e);
+                        error!("This usually means the required system libraries are not installed.");
+                        error!("On Ubuntu/Debian, try installing: sudo apt install libayatana-appindicator3-1");
+                        error!("Alternative: sudo apt install libappindicator3-1");
+                        std::process::exit(1);
+                    }
+                    _ => {
+                        error!("Timeout waiting for tray creation");
+                        std::process::exit(1);
+                    }
+                }
+            }
        }
    }

-    fn user_event(&mut self, event_loop: &winit::event_loop::ActiveEventLoop, event: crate::gui::UserEvent) {
+    fn user_event(
+        &mut self,
+        event_loop: &winit::event_loop::ActiveEventLoop,
+        event: crate::gui::UserEvent,
+    ) {
        match event {
            crate::gui::UserEvent::TrayIconEvent => {}
            crate::gui::UserEvent::UpdateMenu => {
@@ -246,12 +432,23 @@ pub async fn run_tray_app() -> std::io::Result<()> {
        EventLoop::<crate::gui::UserEvent>::with_user_event()
            .with_activation_policy(ActivationPolicy::Accessory)
            .build()
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("Failed to create event loop: {}", e)))?
+            .map_err(|e| {
+                std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    format!("Failed to create event loop: {}", e),
+                )
+            })?
    };

    #[cfg(not(target_os = "macos"))]
-    let event_loop = EventLoop::<crate::gui::UserEvent>::with_user_event().build()
-        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("Failed to create event loop: {}", e)))?;
+    let event_loop = EventLoop::<crate::gui::UserEvent>::with_user_event()
+        .build()
+        .map_err(|e| {
+            std::io::Error::new(
+                std::io::ErrorKind::Other,
+                format!("Failed to create event loop: {}", e),
+            )
+        })?;

    let proxy = event_loop.create_proxy();

@@ -268,8 +465,12 @@ pub async fn run_tray_app() -> std::io::Result<()> {

    let mut app = TrayApplication::new(proxy);

-    event_loop.run_app(&mut app)
-        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("Event loop error: {:?}", e)))?;
+    event_loop.run_app(&mut app).map_err(|e| {
+        std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("Event loop error: {:?}", e),
+        )
+    })?;

    Ok(())
 }
--- a/src/gui/tray/icon.rs
+++ b/src/gui/tray/icon.rs
@@ -1,10 +1,10 @@
+use crate::gui::common::{perform_sync, KhmSettings};
 use log::{error, info};
 use std::sync::{Arc, Mutex};
 use tray_icon::{
-    menu::{Menu, MenuItem, MenuId},
+    menu::{Menu, MenuId, MenuItem},
    TrayIcon, TrayIconBuilder,
 };
-use crate::gui::common::{KhmSettings, perform_sync};

 #[derive(Debug, Clone)]
 pub struct SyncStatus {
@@ -30,17 +30,22 @@ pub struct TrayMenuIds {
 }

 /// Create tray icon with menu
-pub fn create_tray_icon(settings: &KhmSettings, sync_status: &SyncStatus) -> (TrayIcon, TrayMenuIds) {
+pub fn create_tray_icon(
+    settings: &KhmSettings,
+    sync_status: &SyncStatus,
+) -> (TrayIcon, TrayMenuIds) {
    // Create simple blue icon
-    let icon_data: Vec<u8> = (0..32*32).flat_map(|i| {
-        let y = i / 32;
-        let x = i % 32;
-        if x < 2 || x >= 30 || y < 2 || y >= 30 {
-            [255, 255, 255, 255] // White border
-        } else {
-            [64, 128, 255, 255] // Blue center
-        }
-    }).collect();
+    let icon_data: Vec<u8> = (0..32 * 32)
+        .flat_map(|i| {
+            let y = i / 32;
+            let x = i % 32;
+            if x < 2 || x >= 30 || y < 2 || y >= 30 {
+                [255, 255, 255, 255] // White border
+            } else {
+                [64, 128, 255, 255] // Blue center
+            }
+        })
+        .collect();

    let icon = tray_icon::Icon::from_rgba(icon_data, 32, 32).unwrap();
    let menu = Menu::new();
@@ -60,27 +65,38 @@ pub fn create_tray_icon(settings: &KhmSettings, sync_status: &SyncStatus) -> (Tr
    };
    menu.append(&MenuItem::new(flow_text, false, None)).unwrap();

-    let is_auto_sync_enabled = !settings.host.is_empty() && !settings.flow.is_empty() && settings.in_place;
-    let sync_text = format!("Auto sync: {} ({}min)", 
-                           if is_auto_sync_enabled { "On" } else { "Off" },
-                           settings.auto_sync_interval_minutes);
-    menu.append(&MenuItem::new(&sync_text, false, None)).unwrap();
+    let is_auto_sync_enabled =
+        !settings.host.is_empty() && !settings.flow.is_empty() && settings.in_place;
+    let sync_text = format!(
+        "Auto sync: {} ({}min)",
+        if is_auto_sync_enabled { "On" } else { "Off" },
+        settings.auto_sync_interval_minutes
+    );
+    menu.append(&MenuItem::new(&sync_text, false, None))
+        .unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Sync Now menu item
-    let sync_item = MenuItem::new("Sync Now", !settings.host.is_empty() && !settings.flow.is_empty(), None);
+    let sync_item = MenuItem::new(
+        "Sync Now",
+        !settings.host.is_empty() && !settings.flow.is_empty(),
+        None,
+    );
    let sync_id = sync_item.id().clone();
    menu.append(&sync_item).unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Settings menu item
    let settings_item = MenuItem::new("Settings", true, None);
    let settings_id = settings_item.id().clone();
    menu.append(&settings_item).unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Quit menu item
    let quit_item = MenuItem::new("Quit", true, None);
@@ -125,27 +141,38 @@ pub fn update_tray_menu(tray_icon: &TrayIcon, settings: &KhmSettings) -> TrayMen
    };
    menu.append(&MenuItem::new(flow_text, false, None)).unwrap();

-    let is_auto_sync_enabled = !settings.host.is_empty() && !settings.flow.is_empty() && settings.in_place;
-    let sync_text = format!("Auto sync: {} ({}min)", 
-                           if is_auto_sync_enabled { "On" } else { "Off" },
-                           settings.auto_sync_interval_minutes);
-    menu.append(&MenuItem::new(&sync_text, false, None)).unwrap();
+    let is_auto_sync_enabled =
+        !settings.host.is_empty() && !settings.flow.is_empty() && settings.in_place;
+    let sync_text = format!(
+        "Auto sync: {} ({}min)",
+        if is_auto_sync_enabled { "On" } else { "Off" },
+        settings.auto_sync_interval_minutes
+    );
+    menu.append(&MenuItem::new(&sync_text, false, None))
+        .unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Sync Now menu item
-    let sync_item = MenuItem::new("Sync Now", !settings.host.is_empty() && !settings.flow.is_empty(), None);
+    let sync_item = MenuItem::new(
+        "Sync Now",
+        !settings.host.is_empty() && !settings.flow.is_empty(),
+        None,
+    );
    let sync_id = sync_item.id().clone();
    menu.append(&sync_item).unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Settings menu item
    let settings_item = MenuItem::new("Settings", true, None);
    let settings_id = settings_item.id().clone();
    menu.append(&settings_item).unwrap();

-    menu.append(&tray_icon::menu::PredefinedMenuItem::separator()).unwrap();
+    menu.append(&tray_icon::menu::PredefinedMenuItem::separator())
+        .unwrap();

    // Quit menu item
    let quit_item = MenuItem::new("Quit", true, None);
@@ -163,7 +190,10 @@ pub fn update_tray_menu(tray_icon: &TrayIcon, settings: &KhmSettings) -> TrayMen

 /// Create tooltip text for tray icon
 pub fn create_tooltip(settings: &KhmSettings, sync_status: &SyncStatus) -> String {
-    let mut tooltip = format!("KHM - SSH Key Manager\nHost: {}\nFlow: {}", settings.host, settings.flow);
+    let mut tooltip = format!(
+        "KHM - SSH Key Manager\nHost: {}\nFlow: {}",
+        settings.host, settings.flow
+    );

    if let Some(keys_count) = sync_status.last_sync_keys {
        tooltip.push_str(&format!("\nLast sync: {} keys", keys_count));
@@ -186,17 +216,23 @@ pub fn create_tooltip(settings: &KhmSettings, sync_status: &SyncStatus) -> Strin
 pub fn start_auto_sync_task(
    settings: Arc<Mutex<KhmSettings>>,
    sync_status: Arc<Mutex<SyncStatus>>,
-    event_sender: winit::event_loop::EventLoopProxy<crate::gui::UserEvent>
+    event_sender: winit::event_loop::EventLoopProxy<crate::gui::UserEvent>,
 ) -> Option<std::thread::JoinHandle<()>> {
    let initial_settings = settings.lock().unwrap().clone();

    // Only start auto sync if settings are valid and in_place is enabled
-    if initial_settings.host.is_empty() || initial_settings.flow.is_empty() || !initial_settings.in_place {
+    if initial_settings.host.is_empty()
+        || initial_settings.flow.is_empty()
+        || !initial_settings.in_place
+    {
        info!("Auto sync disabled or settings invalid");
        return None;
    }

-    info!("Starting auto sync with interval {} minutes", initial_settings.auto_sync_interval_minutes);
+    info!(
+        "Starting auto sync with interval {} minutes",
+        initial_settings.auto_sync_interval_minutes
+    );

    let handle = std::thread::spawn(move || {
        // Initial sync on startup
@@ -207,7 +243,10 @@ pub fn start_auto_sync_task(
            rt.block_on(async {
                match perform_sync(&current_settings).await {
                    Ok(keys_count) => {
-                        info!("Initial sync completed successfully with {} keys", keys_count);
+                        info!(
+                            "Initial sync completed successfully with {} keys",
+                            keys_count
+                        );
                        let mut status = sync_status.lock().unwrap();
                        status.last_sync_time = Some(std::time::Instant::now());
                        status.last_sync_keys = Some(keys_count);
@@ -222,11 +261,9 @@ pub fn start_auto_sync_task(

        // Start menu update timer
        let timer_sender = event_sender.clone();
-        std::thread::spawn(move || {
-            loop {
-                std::thread::sleep(std::time::Duration::from_secs(1));
-                let _ = timer_sender.send_event(crate::gui::UserEvent::UpdateMenu);
-            }
+        std::thread::spawn(move || loop {
+            std::thread::sleep(std::time::Duration::from_secs(1));
+            let _ = timer_sender.send_event(crate::gui::UserEvent::UpdateMenu);
        });

        // Periodic sync
@@ -235,7 +272,10 @@ pub fn start_auto_sync_task(
            std::thread::sleep(std::time::Duration::from_secs(interval_minutes as u64 * 60));

            let current_settings = settings.lock().unwrap().clone();
-            if current_settings.host.is_empty() || current_settings.flow.is_empty() || !current_settings.in_place {
+            if current_settings.host.is_empty()
+                || current_settings.flow.is_empty()
+                || !current_settings.in_place
+            {
                info!("Auto sync stopped due to invalid settings or disabled in_place");
                break;
            }
--- a/src/gui/tray/mod.rs
+++ b/src/gui/tray/mod.rs
@@ -2,5 +2,7 @@ mod app;
 mod icon;

 pub use app::*;
-pub use icon::{SyncStatus, TrayMenuIds, create_tray_icon, update_tray_menu, 
-               create_tooltip, start_auto_sync_task, update_sync_status};
+pub use icon::{
+    create_tooltip, create_tray_icon, start_auto_sync_task, update_sync_status, update_tray_menu,
+    SyncStatus, TrayMenuIds,
+};
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -0,0 +1,119 @@
+pub mod client;
+pub mod db;
+pub mod gui;
+pub mod server;
+#[cfg(feature = "web")]
+pub mod web;
+#[cfg(feature = "web-gui")]
+pub mod web_gui;
+
+use clap::Parser;
+
+// Common Args structure used by all binaries
+#[derive(Parser, Debug, Clone)]
+pub struct Args {
+    /// Run in server mode (default: false)
+    #[arg(long, help = "Run in server mode")]
+    pub server: bool,
+
+    /// Hide console window and run in background (default: auto when no arguments)
+    #[arg(long, help = "Hide console window and run in background")]
+    pub daemon: bool,
+
+    /// Run settings UI window
+    #[arg(long, help = "Run settings UI window")]
+    pub settings_ui: bool,
+
+    /// Update the known_hosts file with keys from the server after sending keys (default: false)
+    #[arg(
+        long,
+        help = "Server mode: Sync the known_hosts file with keys from the server"
+    )]
+    pub in_place: bool,
+
+    /// Comma-separated list of flows to manage (default: default)
+    #[arg(long, default_value = "default", value_parser, num_args = 1.., value_delimiter = ',', help = "Server mode: Comma-separated list of flows to manage")]
+    pub flows: Vec<String>,
+
+    /// IP address to bind the server or client to (default: 127.0.0.1)
+    #[arg(
+        short,
+        long,
+        default_value = "127.0.0.1",
+        help = "Server mode: IP address to bind the server to"
+    )]
+    pub ip: String,
+
+    /// Port to bind the server or client to (default: 8080)
+    #[arg(
+        short,
+        long,
+        default_value = "8080",
+        help = "Server mode: Port to bind the server to"
+    )]
+    pub port: u16,
+
+    /// Hostname or IP address of the PostgreSQL database (default: 127.0.0.1)
+    #[arg(
+        long,
+        default_value = "127.0.0.1",
+        help = "Server mode: Hostname or IP address of the PostgreSQL database"
+    )]
+    pub db_host: String,
+
+    /// Name of the PostgreSQL database (default: khm)
+    #[arg(
+        long,
+        default_value = "khm",
+        help = "Server mode: Name of the PostgreSQL database"
+    )]
+    pub db_name: String,
+
+    /// Username for the PostgreSQL database (required in server mode)
+    #[arg(
+        long,
+        required_if_eq("server", "true"),
+        help = "Server mode: Username for the PostgreSQL database"
+    )]
+    pub db_user: Option<String>,
+
+    /// Password for the PostgreSQL database (required in server mode)
+    #[arg(
+        long,
+        required_if_eq("server", "true"),
+        help = "Server mode: Password for the PostgreSQL database"
+    )]
+    pub db_password: Option<String>,
+
+    /// Host address of the server to connect to in client mode (required in client mode)
+    #[arg(
+        long,
+        required_if_eq("server", "false"),
+        help = "Client mode: Full host address of the server to connect to. Like https://khm.example.com"
+    )]
+    pub host: Option<String>,
+
+    /// Flow name to use on the server
+    #[arg(
+        long,
+        required_if_eq("server", "false"),
+        help = "Client mode: Flow name to use on the server"
+    )]
+    pub flow: Option<String>,
+
+    /// Path to the known_hosts file (default: ~/.ssh/known_hosts)
+    #[arg(
+        long,
+        default_value = "~/.ssh/known_hosts",
+        help = "Client mode: Path to the known_hosts file"
+    )]
+    pub known_hosts: String,
+
+    /// Basic auth string for client mode. Format: user:pass
+    #[arg(long, default_value = "", help = "Client mode: Basic Auth credentials")]
+    pub basic_auth: String,
+}
+
+// Re-export WASM functions for wasm-pack
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub use web_gui::wasm::*;
--- a/src/server.rs
+++ b/src/server.rs
@@ -300,48 +300,69 @@ pub async fn run_server(args: crate::Args) -> std::io::Result<()> {

    info!("Starting HTTP server on {}:{}", args.ip, args.port);
    HttpServer::new(move || {
-        App::new()
+        let mut app = App::new()
            .app_data(web::Data::new(flows.clone()))
            .app_data(web::Data::new(db_client.clone()))
            .app_data(allowed_flows.clone())
-            // API routes
-            .route("/api/version", web::get().to(crate::web::get_version_api))
-            .route("/api/flows", web::get().to(crate::web::get_flows_api))
-            .route(
-                "/{flow_id}/scan-dns",
-                web::post().to(crate::web::scan_dns_resolution),
-            )
-            .route(
-                "/{flow_id}/bulk-deprecate",
-                web::post().to(crate::web::bulk_deprecate_servers),
-            )
-            .route(
-                "/{flow_id}/bulk-restore",
-                web::post().to(crate::web::bulk_restore_servers),
-            )
-            .route(
-                "/{flow_id}/keys/{server}",
-                web::delete().to(crate::web::delete_key_by_server),
-            )
-            .route(
-                "/{flow_id}/keys/{server}/restore",
-                web::post().to(crate::web::restore_key_by_server),
-            )
-            .route(
-                "/{flow_id}/keys/{server}/delete",
-                web::delete().to(crate::web::permanently_delete_key_by_server),
-            )
            // Original API routes
            .route("/{flow_id}/keys", web::get().to(get_keys))
-            .route("/{flow_id}/keys", web::post().to(add_keys))
-            // Web interface routes
-            .route("/", web::get().to(crate::web::serve_web_interface))
-            .route(
-                "/static/{filename:.*}",
-                web::get().to(crate::web::serve_static_file),
-            )
+            .route("/{flow_id}/keys", web::post().to(add_keys));
+        
+        #[cfg(feature = "web")]
+        {
+            app = app.configure(configure_web_routes);
+        }
+        
+        app
    })
    .bind((args.ip.as_str(), args.port))?
    .run()
    .await
 }
+
+#[cfg(feature = "web")]
+fn configure_web_routes(cfg: &mut web::ServiceConfig) {
+    cfg
+        // API routes
+        .route("/api/version", web::get().to(crate::web::get_version_api))
+        .route("/api/flows", web::get().to(crate::web::get_flows_api))
+        .route(
+            "/{flow_id}/scan-dns",
+            web::post().to(crate::web::scan_dns_resolution),
+        )
+        .route(
+            "/{flow_id}/bulk-deprecate",
+            web::post().to(crate::web::bulk_deprecate_servers),
+        )
+        .route(
+            "/{flow_id}/bulk-restore",
+            web::post().to(crate::web::bulk_restore_servers),
+        )
+        .route(
+            "/{flow_id}/keys/{server}",
+            web::delete().to(crate::web::delete_key_by_server),
+        )
+        .route(
+            "/{flow_id}/keys/{server}/restore",
+            web::post().to(crate::web::restore_key_by_server),
+        )
+        .route(
+            "/{flow_id}/keys/{server}/delete",
+            web::delete().to(crate::web::permanently_delete_key_by_server),
+        )
+        // Web interface routes
+        .route("/", web::get().to(crate::web::serve_web_interface))
+        .route(
+            "/static/{filename:.*}",
+            web::get().to(crate::web::serve_static_file),
+        );
+    
+    // Web GUI routes
+    cfg.route("/gui", web::get().to(crate::web_gui::serve_egui_interface))
+        .route("/gui/", web::get().to(crate::web_gui::serve_egui_interface))
+        .route("/gui/config", web::get().to(crate::web_gui::get_gui_config))
+        .route("/gui/state", web::get().to(crate::web_gui::get_gui_state))
+        .route("/gui/settings", web::post().to(crate::web_gui::update_gui_settings))
+        .route("/wasm/{filename:.*}", web::get().to(crate::web_gui::serve_wasm_file));
+}
+
--- a/src/wasm_lib.rs
+++ b/src/wasm_lib.rs
@@ -0,0 +1,265 @@
+// Минимальная WASM библиотека только для egui интерфейса
+use wasm_bindgen::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// Основные структуры данных (копии из main lib)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SshKey {
+    pub server: String,
+    pub public_key: String,
+    #[serde(default)]
+    pub deprecated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DnsResult {
+    pub server: String,
+    pub resolved: bool,
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct AdminSettings {
+    pub server_url: String,
+    pub basic_auth: String,
+    pub selected_flow: String,
+    pub auto_refresh: bool,
+    pub refresh_interval: u32,
+}
+
+impl Default for AdminSettings {
+    fn default() -> Self {
+        let server_url = {
+            #[cfg(target_arch = "wasm32")]
+            {
+                web_sys::window()
+                    .and_then(|w| w.location().origin().ok())
+                    .unwrap_or_else(|| "http://localhost:8080".to_string())
+            }
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                "http://localhost:8080".to_string()
+            }
+        };
+        
+        Self {
+            server_url,
+            basic_auth: String::new(),
+            selected_flow: String::new(),
+            auto_refresh: false,
+            refresh_interval: 30,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AdminState {
+    pub keys: Vec<SshKey>,
+    pub filtered_keys: Vec<SshKey>,
+    pub search_term: String,
+    pub show_deprecated_only: bool,
+    pub selected_servers: HashMap<String, bool>,
+    pub expanded_servers: HashMap<String, bool>,
+    pub current_operation: String,
+}
+
+impl Default for AdminState {
+    fn default() -> Self {
+        Self {
+            keys: Vec::new(),
+            filtered_keys: Vec::new(),
+            search_term: String::new(),
+            show_deprecated_only: false,
+            selected_servers: HashMap::new(),
+            expanded_servers: HashMap::new(),
+            current_operation: String::new(),
+        }
+    }
+}
+
+impl AdminState {
+    pub fn filter_keys(&mut self) {
+        self.filtered_keys = self.keys.iter()
+            .filter(|key| {
+                if self.show_deprecated_only && !key.deprecated {
+                    return false;
+                }
+                if !self.show_deprecated_only && key.deprecated {
+                    return false;
+                }
+                if !self.search_term.is_empty() {
+                    let search_lower = self.search_term.to_lowercase();
+                    return key.server.to_lowercase().contains(&search_lower) ||
+                           key.public_key.to_lowercase().contains(&search_lower);
+                }
+                true
+            })
+            .cloned()
+            .collect();
+    }
+}
+
+// Простое egui приложение
+pub struct WebAdminApp {
+    settings: AdminSettings,
+    admin_state: AdminState,
+    status_message: String,
+}
+
+impl Default for WebAdminApp {
+    fn default() -> Self {
+        Self {
+            settings: AdminSettings::default(),
+            admin_state: AdminState::default(),
+            status_message: "Ready".to_string(),
+        }
+    }
+}
+
+impl eframe::App for WebAdminApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("🔑 KHM Web Admin Panel");
+            ui.separator();
+            
+            // Connection Settings
+            egui::CollapsingHeader::new("⚙️ Connection Settings")
+                .default_open(true)
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        ui.label("Server URL:");
+                        ui.text_edit_singleline(&mut self.settings.server_url);
+                    });
+                    
+                    ui.horizontal(|ui| {
+                        ui.label("Basic Auth:");
+                        ui.add(egui::TextEdit::singleline(&mut self.settings.basic_auth).password(true));
+                    });
+                    
+                    ui.horizontal(|ui| {
+                        ui.label("Flow:");
+                        ui.text_edit_singleline(&mut self.settings.selected_flow);
+                    });
+                    
+                    ui.horizontal(|ui| {
+                        if ui.button("Test Connection").clicked() {
+                            self.status_message = "Testing connection... (WASM demo mode)".to_string();
+                        }
+                        if ui.button("Load Keys").clicked() {
+                            // Add demo data
+                            self.admin_state.keys = vec![
+                                SshKey {
+                                    server: "demo-server-1".to_string(),
+                                    public_key: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC demo key 1".to_string(),
+                                    deprecated: false,
+                                },
+                                SshKey {
+                                    server: "demo-server-2".to_string(),
+                                    public_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5 demo key 2".to_string(),
+                                    deprecated: true,
+                                },
+                            ];
+                            self.admin_state.filter_keys();
+                            self.status_message = format!("Loaded {} demo keys", self.admin_state.keys.len());
+                        }
+                    });
+                });
+            
+            ui.add_space(10.0);
+            
+            // Keys display
+            if !self.admin_state.filtered_keys.is_empty() {
+                egui::CollapsingHeader::new("🔑 SSH Keys")
+                    .default_open(true)
+                    .show(ui, |ui| {
+                        ui.horizontal(|ui| {
+                            ui.label("Search:");
+                            let search_response = ui.text_edit_singleline(&mut self.admin_state.search_term);
+                            if search_response.changed() {
+                                self.admin_state.filter_keys();
+                            }
+                        });
+                        
+                        ui.horizontal(|ui| {
+                            if ui.selectable_label(!self.admin_state.show_deprecated_only, "✅ Active").clicked() {
+                                self.admin_state.show_deprecated_only = false;
+                                self.admin_state.filter_keys();
+                            }
+                            if ui.selectable_label(self.admin_state.show_deprecated_only, "❗ Deprecated").clicked() {
+                                self.admin_state.show_deprecated_only = true;
+                                self.admin_state.filter_keys();
+                            }
+                        });
+                        
+                        ui.separator();
+                        
+                        for key in &self.admin_state.filtered_keys {
+                            ui.group(|ui| {
+                                ui.horizontal(|ui| {
+                                    if key.deprecated {
+                                        ui.colored_label(egui::Color32::RED, "❗ DEPRECATED");
+                                    } else {
+                                        ui.colored_label(egui::Color32::GREEN, "✅ ACTIVE");
+                                    }
+                                    
+                                    ui.label(&key.server);
+                                    ui.monospace(&key.public_key[..50.min(key.public_key.len())]);
+                                    
+                                    if ui.small_button("Copy").clicked() {
+                                        ui.output_mut(|o| o.copied_text = key.public_key.clone());
+                                    }
+                                });
+                            });
+                        }
+                    });
+            }
+            
+            ui.add_space(10.0);
+            
+            // Status
+            ui.horizontal(|ui| {
+                ui.label("Status:");
+                ui.colored_label(egui::Color32::LIGHT_BLUE, &self.status_message);
+            });
+            
+            // Info
+            ui.separator();
+            ui.label("ℹ️ This is a demo WASM version. For full functionality, the server API integration is needed.");
+        });
+    }
+}
+
+/// WASM entry point
+#[wasm_bindgen]
+pub fn start_web_admin(canvas_id: &str) -> Result<(), JsValue> {
+    console_error_panic_hook::set_once();
+    tracing_wasm::set_as_global_default();
+    
+    let web_options = eframe::WebOptions::default();
+    let canvas_id = canvas_id.to_string();
+    
+    wasm_bindgen_futures::spawn_local(async move {
+        let app = WebAdminApp::default();
+        
+        let result = eframe::WebRunner::new()
+            .start(
+                &canvas_id,
+                web_options,
+                Box::new(|_cc| Ok(Box::new(app))),
+            )
+            .await;
+            
+        match result {
+            Ok(_) => web_sys::console::log_1(&"eframe started successfully".into()),
+            Err(e) => web_sys::console::error_1(&format!("Failed to start eframe: {:?}", e).into()),
+        }
+    });
+    
+    Ok(())
+}
+
+#[wasm_bindgen(start)]
+pub fn wasm_main() {
+    console_error_panic_hook::set_once();
+}
--- a/src/web.rs
+++ b/src/web.rs
@@ -1,14 +1,14 @@
 use actix_web::{web, HttpResponse, Result};
+use futures::future;
 use log::info;
 use rust_embed::RustEmbed;
+use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::sync::Arc;
-use trust_dns_resolver::TokioAsyncResolver;
-use trust_dns_resolver::config::*;
-use serde::{Deserialize, Serialize};
-use futures::future;
 use tokio::sync::Semaphore;
 use tokio::time::{timeout, Duration};
+use trust_dns_resolver::config::*;
+use trust_dns_resolver::TokioAsyncResolver;

 use crate::db::ReconnectingDbClient;
 use crate::server::Flows;
@@ -17,7 +17,7 @@ use crate::server::Flows;
 #[folder = "static/"]
 struct StaticAssets;

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct DnsResolutionResult {
    pub server: String,
    pub resolved: bool,
@@ -41,10 +41,7 @@ async fn check_dns_resolution(hostname: String, semaphore: Arc<Semaphore>) -> Dn
        }
    };

-    let resolver = TokioAsyncResolver::tokio(
-        ResolverConfig::default(),
-        ResolverOpts::default(),
-    );
+    let resolver = TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());

    let lookup_result = timeout(Duration::from_secs(5), resolver.lookup_ip(&hostname)).await;

@@ -88,7 +85,10 @@ pub async fn scan_dns_resolution(
 ) -> Result<HttpResponse> {
    let flow_id_str = path.into_inner();

-    info!("API request to scan DNS resolution for flow '{}'"  , flow_id_str);
+    info!(
+        "API request to scan DNS resolution for flow '{}'",
+        flow_id_str
+    );

    if !allowed_flows.contains(&flow_id_str) {
        return Ok(HttpResponse::Forbidden().json(json!({
@@ -114,7 +114,10 @@ pub async fn scan_dns_resolution(

    drop(flows_guard);

-    info!("Scanning DNS resolution for {} unique hosts", hostnames.len());
+    info!(
+        "Scanning DNS resolution for {} unique hosts",
+        hostnames.len()
+    );

    // Limit concurrent DNS requests to prevent "too many open files" error
    let semaphore = Arc::new(Semaphore::new(20));
@@ -128,7 +131,11 @@ pub async fn scan_dns_resolution(
    let results = future::join_all(scan_futures).await;

    let unresolved_count = results.iter().filter(|r| !r.resolved).count();
-    info!("DNS scan complete: {} unresolved out of {} hosts", unresolved_count, results.len());
+    info!(
+        "DNS scan complete: {} unresolved out of {} hosts",
+        unresolved_count,
+        results.len()
+    );

    Ok(HttpResponse::Ok().json(json!({
        "results": results,
@@ -147,7 +154,11 @@ pub async fn bulk_deprecate_servers(
 ) -> Result<HttpResponse> {
    let flow_id_str = path.into_inner();

-    info!("API request to bulk deprecate {} servers in flow '{}'", request.servers.len(), flow_id_str);
+    info!(
+        "API request to bulk deprecate {} servers in flow '{}'",
+        request.servers.len(),
+        flow_id_str
+    );

    if !allowed_flows.contains(&flow_id_str) {
        return Ok(HttpResponse::Forbidden().json(json!({
@@ -161,7 +172,11 @@ pub async fn bulk_deprecate_servers(
        .await
    {
        Ok(count) => {
-            info!("Bulk deprecated {} key(s) for {} servers", count, request.servers.len());
+            info!(
+                "Bulk deprecated {} key(s) for {} servers",
+                count,
+                request.servers.len()
+            );
            count
        }
        Err(e) => {
@@ -203,7 +218,11 @@ pub async fn bulk_restore_servers(
 ) -> Result<HttpResponse> {
    let flow_id_str = path.into_inner();

-    info!("API request to bulk restore {} servers in flow '{}'", request.servers.len(), flow_id_str);
+    info!(
+        "API request to bulk restore {} servers in flow '{}'",
+        request.servers.len(),
+        flow_id_str
+    );

    if !allowed_flows.contains(&flow_id_str) {
        return Ok(HttpResponse::Forbidden().json(json!({
@@ -217,7 +236,11 @@ pub async fn bulk_restore_servers(
        .await
    {
        Ok(count) => {
-            info!("Bulk restored {} key(s) for {} servers", count, request.servers.len());
+            info!(
+                "Bulk restored {} key(s) for {} servers",
+                count,
+                request.servers.len()
+            );
            count
        }
        Err(e) => {
--- a/src/web_gui.rs
+++ b/src/web_gui.rs
@@ -0,0 +1,288 @@
+use actix_web::{HttpResponse, Result, web};
+use serde_json::json;
+use log::info;
+
+#[cfg(feature = "web-gui")]
+pub mod app;
+#[cfg(feature = "web-gui")]
+pub mod state;
+#[cfg(feature = "web-gui")]
+pub mod ui;
+#[cfg(all(feature = "web-gui", not(target_arch = "wasm32")))]
+pub mod api;
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub mod wasm_api;
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub mod wasm;
+
+
+/// Serve the egui web GUI interface
+pub async fn serve_egui_interface() -> Result<HttpResponse> {
+    #[cfg(feature = "web-gui")]
+    {
+        let html = r#"
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>KHM Admin Panel</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <style>
+        html, body {
+            margin: 0;
+            padding: 0;
+            width: 100%;
+            height: 100%;
+            background: #2b2b2b;
+            font-family: system-ui, sans-serif;
+        }
+        
+        canvas {
+            width: 100vw;
+            height: 100vh;
+            display: block;
+        }
+        
+        #loading {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            color: white;
+            font-size: 18px;
+            z-index: 1000;
+            text-align: center;
+        }
+        
+        .spinner {
+            border: 3px solid rgba(255,255,255,0.3);
+            border-radius: 50%;
+            border-top: 3px solid #667eea;
+            width: 40px;
+            height: 40px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 20px;
+        }
+        
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body>
+    <div id="loading">
+        <div class="spinner"></div>
+        Loading KHM Admin Panel...
+    </div>
+    
+    <canvas id="the_canvas_id"></canvas>
+
+    <script type="module">
+        import init, { start_web_admin } from './wasm/khm_wasm.js';
+        
+        async function run() {
+            try {
+                // Initialize WASM module
+                await init();
+                
+                // Hide loading indicator
+                document.getElementById('loading').style.display = 'none';
+                
+                // Start the egui web app
+                start_web_admin('the_canvas_id');
+                
+                console.log('KHM Web Admin Panel started successfully');
+            } catch (error) {
+                console.error('Failed to start KHM Web Admin Panel:', error);
+                
+                // Show error message
+                document.getElementById('loading').innerHTML = `
+                    <div style="color: #ff6b6b; text-align: center;">
+                        <h3>⚠️ WASM Module Not Available</h3>
+                        <p>The egui web interface requires WASM compilation.</p>
+                        <p style="font-size: 14px; color: #ccc; margin: 20px 0;">Build steps:</p>
+                        <div style="background: #333; padding: 15px; border-radius: 5px; font-family: monospace; text-align: left; max-width: 600px; margin: 0 auto;">
+                            <div style="color: #888; margin-bottom: 10px;"># Install wasm-pack</div>
+                            <div style="color: #fff;">cargo install wasm-pack</div>
+                            <div style="color: #888; margin: 10px 0;"># Build WASM module</div>
+                            <div style="color: #fff;">wasm-pack build --target web --out-dir wasm --features web-gui</div>
+                            <div style="color: #888; margin: 10px 0;"># Restart server</div>
+                            <div style="color: #fff;">cargo run --features "server,web,web-gui"</div>
+                        </div>
+                        <p style="font-size: 12px; color: #888; margin-top: 20px;">Error: ${error.message}</p>
+                    </div>
+                `;
+            }
+        }
+        
+        run();
+    </script>
+</body>
+</html>
+        "#;
+        
+        Ok(HttpResponse::Ok()
+            .content_type("text/html; charset=utf-8")
+            .body(html))
+    }
+    
+    #[cfg(not(feature = "web-gui"))]
+    {
+        let html = r#"
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>KHM Admin Panel - Not Available</title>
+    <style>
+        body {
+            font-family: system-ui, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+            text-align: center;
+        }
+    </style>
+</head>
+<body>
+    <div>
+        <h1>⚠️ Web GUI Not Available</h1>
+        <p>This server was compiled without web-gui support.</p>
+        <p>Please rebuild with <code>--features web-gui</code> to enable the admin interface.</p>
+    </div>
+</body>
+</html>
+        "#;
+        
+        Ok(HttpResponse::Ok()
+            .content_type("text/html; charset=utf-8")
+            .body(html))
+    }
+}
+
+/// API endpoint to get GUI configuration
+pub async fn get_gui_config(
+    flows: web::Data<crate::server::Flows>,
+    allowed_flows: web::Data<Vec<String>>,
+) -> Result<HttpResponse> {
+    info!("Web GUI config requested");
+    
+    let flows_guard = flows.lock().unwrap();
+    let available_flows: Vec<String> = flows_guard.iter().map(|f| f.name.clone()).collect();
+    
+    Ok(HttpResponse::Ok().json(json!({
+        "version": env!("CARGO_PKG_VERSION"),
+        "gui_ready": cfg!(feature = "web-gui"),
+        "features": ["key_management", "bulk_operations", "real_time_updates"],
+        "available_flows": available_flows,
+        "allowed_flows": &**allowed_flows,
+        "api_endpoints": {
+            "flows": "/api/flows",
+            "keys": "/{flow}/keys",
+            "deprecate": "/{flow}/keys/{server}",
+            "restore": "/{flow}/keys/{server}/restore", 
+            "delete": "/{flow}/keys/{server}/delete",
+            "bulk_deprecate": "/{flow}/bulk-deprecate",
+            "bulk_restore": "/{flow}/bulk-restore",
+            "dns_scan": "/{flow}/scan-dns"
+        }
+    })))
+}
+
+/// API endpoint for web GUI state management
+pub async fn get_gui_state(
+    flows: web::Data<crate::server::Flows>,
+    allowed_flows: web::Data<Vec<String>>,
+) -> Result<HttpResponse> {
+    info!("Web GUI state requested");
+    
+    let flows_guard = flows.lock().unwrap();
+    let flow_data: Vec<_> = flows_guard.iter().map(|f| json!({
+        "name": f.name,
+        "servers_count": f.servers.len(),
+        "active_keys": f.servers.iter().filter(|k| !k.deprecated).count(),
+        "deprecated_keys": f.servers.iter().filter(|k| k.deprecated).count()
+    })).collect();
+    
+    Ok(HttpResponse::Ok().json(json!({
+        "flows": flow_data,
+        "allowed_flows": &**allowed_flows,
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    })))
+}
+
+/// API endpoint to update GUI settings  
+pub async fn update_gui_settings(
+    settings: web::Json<serde_json::Value>,
+) -> Result<HttpResponse> {
+    info!("Web GUI settings updated: {:?}", settings);
+    
+    Ok(HttpResponse::Ok().json(json!({
+        "status": "success",
+        "message": "Settings updated successfully",
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    })))
+}
+
+/// Serve WASM files for egui web application
+pub async fn serve_wasm_file(path: web::Path<String>) -> Result<HttpResponse> {
+    let filename = path.into_inner();
+    info!("WASM file requested: {}", filename);
+    
+    // Try to read the actual WASM files from the wasm directory
+    let wasm_dir = std::path::Path::new("wasm");
+    let file_path = wasm_dir.join(&filename);
+    
+    match std::fs::read(&file_path) {
+        Ok(content) => {
+            let content_type = if filename.ends_with(".js") {
+                "application/javascript; charset=utf-8"
+            } else if filename.ends_with(".wasm") {
+                "application/wasm"
+            } else {
+                "application/octet-stream"
+            };
+            
+            info!("Serving WASM file: {} ({} bytes)", filename, content.len());
+            Ok(HttpResponse::Ok()
+                .content_type(content_type)
+                .body(content))
+        }
+        Err(_) => {
+            // Fallback to placeholder if files don't exist
+            let content = match filename.as_str() {
+                "khm_wasm.js" => {
+                    r#"
+// KHM WASM Module Not Found
+// Build the WASM module first:
+// cd khm-wasm && wasm-pack build --target web --out-dir ../wasm
+
+export default function init() {
+    return Promise.reject(new Error('WASM module not found. Run: cd khm-wasm && wasm-pack build --target web --out-dir ../wasm'));
+}
+
+export function start_web_admin(canvas_id) {
+    throw new Error('WASM module not found. Run: cd khm-wasm && wasm-pack build --target web --out-dir ../wasm');
+}
+                    "#
+                }
+                _ => {
+                    return Ok(HttpResponse::NotFound().json(json!({
+                        "error": "WASM file not found",
+                        "filename": filename,
+                        "message": "Run: cd khm-wasm && wasm-pack build --target web --out-dir ../wasm"
+                    })));
+                }
+            };
+            
+            Ok(HttpResponse::Ok()
+                .content_type("application/javascript; charset=utf-8")
+                .body(content))
+        }
+    }
+}
--- a/src/web_gui/api.rs
+++ b/src/web_gui/api.rs
@@ -0,0 +1,399 @@
+use super::state::{SshKey, DnsResult, AdminSettings};
+use log::info;
+use reqwest::Client;
+use std::time::Duration;
+
+/// Create HTTP client for API requests
+fn create_http_client() -> Result<Client, String> {
+    Client::builder()
+        .timeout(Duration::from_secs(30))
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .map_err(|e| format!("Failed to create HTTP client: {}", e))
+}
+
+/// Add basic auth to request if provided
+fn add_auth_if_needed(
+    request: reqwest::RequestBuilder,
+    basic_auth: &str,
+) -> Result<reqwest::RequestBuilder, String> {
+    if basic_auth.is_empty() {
+        return Ok(request);
+    }
+    
+    let auth_parts: Vec<&str> = basic_auth.splitn(2, ':').collect();
+    if auth_parts.len() == 2 {
+        Ok(request.basic_auth(auth_parts[0], Some(auth_parts[1])))
+    } else {
+        Err("Basic auth format should be 'username:password'".to_string())
+    }
+}
+
+/// Check response status for errors
+fn check_response_status(response: &reqwest::Response) -> Result<(), String> {
+    let status = response.status().as_u16();
+    
+    if status == 401 {
+        return Err("Authentication required. Please provide valid basic auth credentials.".to_string());
+    }
+    
+    if status >= 300 && status < 400 {
+        return Err("Server redirects to login page. Authentication may be required.".to_string());
+    }
+    
+    if !response.status().is_success() {
+        return Err(format!(
+            "Server returned error: {} {}",
+            status,
+            response.status().canonical_reason().unwrap_or("Unknown")
+        ));
+    }
+    
+    Ok(())
+}
+
+/// Check if response is HTML instead of JSON
+fn check_html_response(body: &str) -> Result<(), String> {
+    if body.trim_start().starts_with("<!DOCTYPE") || body.trim_start().starts_with("<html") {
+        return Err("Server returned HTML page instead of JSON. This usually means authentication is required or the endpoint is incorrect.".to_string());
+    }
+    Ok(())
+}
+
+/// Get application version from API
+pub async fn get_version(settings: &AdminSettings) -> Result<String, String> {
+    if settings.server_url.is_empty() {
+        return Err("Server URL must be specified".to_string());
+    }
+    
+    let url = format!("{}/api/version", settings.server_url.trim_end_matches('/'));
+    info!("Getting version from: {}", url);
+    
+    let client = create_http_client()?;
+    let mut request = client.get(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))?;
+        
+    check_html_response(&body)?;
+    
+    let version_response: serde_json::Value = serde_json::from_str(&body)
+        .map_err(|e| format!("Failed to parse version: {}", e))?;
+        
+    let version = version_response
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+        
+    info!("KHM server version: {}", version);
+    Ok(version)
+}
+
+/// Test connection to KHM server using existing API endpoint
+pub async fn test_connection(settings: &AdminSettings) -> Result<String, String> {
+    if settings.server_url.is_empty() || settings.selected_flow.is_empty() {
+        return Err("Server URL and flow must be specified".to_string());
+    }
+    
+    let url = format!(
+        "{}/{}/keys",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow
+    );
+    info!("Testing connection to: {}", url);
+    
+    let client = create_http_client()?;
+    let mut request = client.get(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))?;
+        
+    check_html_response(&body)?;
+    
+    let keys: Vec<SshKey> = serde_json::from_str(&body)
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+        
+    let message = format!("Connection successful! Found {} SSH keys from flow '{}'", keys.len(), settings.selected_flow);
+    info!("{}", message);
+    Ok(message)
+}
+
+/// Load available flows from server
+pub async fn load_flows(settings: &AdminSettings) -> Result<Vec<String>, String> {
+    if settings.server_url.is_empty() {
+        return Err("Server URL must be specified".to_string());
+    }
+    
+    let url = format!("{}/api/flows", settings.server_url.trim_end_matches('/'));
+    info!("Loading flows from: {}", url);
+    
+    let client = create_http_client()?;
+    let mut request = client.get(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))?;
+        
+    check_html_response(&body)?;
+    
+    let flows: Vec<String> = serde_json::from_str(&body)
+        .map_err(|e| format!("Failed to parse flows: {}", e))?;
+        
+    info!("Loaded {} flows", flows.len());
+    Ok(flows)
+}
+
+/// Fetch all SSH keys including deprecated ones using existing API endpoint
+pub async fn fetch_keys(settings: &AdminSettings) -> Result<Vec<SshKey>, String> {
+    if settings.server_url.is_empty() || settings.selected_flow.is_empty() {
+        return Err("Server URL and flow must be specified".to_string());
+    }
+    
+    let url = format!(
+        "{}/{}/keys",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow
+    );
+    info!("Fetching keys from: {}", url);
+    
+    let client = create_http_client()?;
+    let mut request = client.get(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))?;
+        
+    check_html_response(&body)?;
+    
+    let keys: Vec<SshKey> = serde_json::from_str(&body)
+        .map_err(|e| format!("Failed to parse keys: {}", e))?;
+        
+    info!("Fetched {} SSH keys", keys.len());
+    Ok(keys)
+}
+
+/// Deprecate a key for a specific server
+pub async fn deprecate_key(
+    settings: &AdminSettings,
+    server: &str,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow,
+        urlencoding::encode(server)
+    );
+    info!("Deprecating key for server '{}' at: {}", server, url);
+    
+    let client = create_http_client()?;
+    let mut request = client.delete(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    Ok(format!("Successfully deprecated key for server '{}'", server))
+}
+
+/// Restore a key for a specific server
+pub async fn restore_key(
+    settings: &AdminSettings,
+    server: &str,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}/restore",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow,
+        urlencoding::encode(server)
+    );
+    info!("Restoring key for server '{}' at: {}", server, url);
+    
+    let client = create_http_client()?;
+    let mut request = client.post(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    Ok(format!("Successfully restored key for server '{}'", server))
+}
+
+/// Delete a key permanently for a specific server
+pub async fn delete_key(
+    settings: &AdminSettings,
+    server: &str,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/keys/{}/delete",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow,
+        urlencoding::encode(server)
+    );
+    info!("Permanently deleting key for server '{}' at: {}", server, url);
+    
+    let client = create_http_client()?;
+    let mut request = client.delete(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    Ok(format!("Successfully deleted key for server '{}'", server))
+}
+
+/// Bulk deprecate multiple servers
+pub async fn bulk_deprecate_servers(
+    settings: &AdminSettings,
+    servers: Vec<String>,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/bulk-deprecate",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow
+    );
+    info!("Bulk deprecating {} servers at: {}", servers.len(), url);
+    
+    let client = create_http_client()?;
+    let mut request = client.post(&url).json(&serde_json::json!({
+        "servers": servers
+    }));
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    Ok("Successfully deprecated selected servers".to_string())
+}
+
+/// Bulk restore multiple servers
+pub async fn bulk_restore_servers(
+    settings: &AdminSettings,
+    servers: Vec<String>,
+) -> Result<String, String> {
+    let url = format!(
+        "{}/{}/bulk-restore",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow
+    );
+    info!("Bulk restoring {} servers at: {}", servers.len(), url);
+    
+    let client = create_http_client()?;
+    let mut request = client.post(&url).json(&serde_json::json!({
+        "servers": servers
+    }));
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    Ok("Successfully restored selected servers".to_string())
+}
+
+/// Scan DNS resolution for servers using existing API endpoint
+pub async fn scan_dns_resolution(
+    settings: &AdminSettings,
+) -> Result<Vec<DnsResult>, String> {
+    let url = format!(
+        "{}/{}/scan-dns",
+        settings.server_url.trim_end_matches('/'),
+        settings.selected_flow
+    );
+    info!("Scanning DNS resolution at: {}", url);
+    
+    let client = create_http_client()?;
+    let mut request = client.post(&url);
+    
+    request = add_auth_if_needed(request, &settings.basic_auth)?;
+    
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+        
+    check_response_status(&response)?;
+    
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))?;
+        
+    // Parse the response format from existing API: {"results": [...], "total": N, "unresolved": N}
+    let api_response: serde_json::Value = serde_json::from_str(&body)
+        .map_err(|e| format!("Failed to parse DNS response: {}", e))?;
+        
+    let results = api_response
+        .get("results")
+        .and_then(|r| serde_json::from_value(r.clone()).ok())
+        .unwrap_or_else(Vec::new);
+        
+    info!("DNS scan completed for {} servers", results.len());
+    Ok(results)
+}
--- a/src/web_gui/app.rs
+++ b/src/web_gui/app.rs
@@ -0,0 +1,590 @@
+use super::state::{AdminSettings, AdminState, ConnectionStatus, AdminOperation};
+use super::ui::{self, ConnectionAction, KeyAction, BulkAction};
+#[cfg(not(target_arch = "wasm32"))]
+use super::api;
+#[cfg(target_arch = "wasm32")]
+use super::wasm_api as api;
+use eframe::egui;
+use std::sync::mpsc;
+
+pub struct WebAdminApp {
+    settings: AdminSettings,
+    admin_state: AdminState,
+    flows: Vec<String>,
+    connection_status: ConnectionStatus,
+    operation_receiver: Option<mpsc::Receiver<AdminOperation>>,
+    last_operation: String,
+    server_version: Option<String>,
+}
+
+impl Default for WebAdminApp {
+    fn default() -> Self {
+        // Get server URL from current location if possible
+        let server_url = {
+            #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+            {
+                web_sys::window()
+                    .and_then(|w| w.location().origin().ok())
+                    .unwrap_or_else(|| "http://localhost:8080".to_string())
+            }
+            #[cfg(not(all(target_arch = "wasm32", feature = "web-gui")))]
+            {
+                "http://localhost:8080".to_string()
+            }
+        };
+        
+        Self {
+            settings: AdminSettings {
+                server_url,
+                ..Default::default()
+            },
+            admin_state: AdminState::default(),
+            flows: Vec::new(),
+            connection_status: ConnectionStatus::Disconnected,
+            operation_receiver: None,
+            last_operation: "Application started".to_string(),
+            server_version: None,
+        }
+    }
+}
+
+impl eframe::App for WebAdminApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        // Handle async operations
+        if let Some(receiver) = &self.operation_receiver {
+            if let Ok(operation) = receiver.try_recv() {
+                self.handle_operation_result(operation);
+                ctx.request_repaint();
+            }
+        }
+        
+        // Use the same UI structure as desktop version
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("🔑 KHM Web Admin Panel");
+            ui.separator();
+            
+            // Connection Settings (always visible for web version)
+            egui::CollapsingHeader::new("⚙️ Connection Settings")
+                .default_open(matches!(self.connection_status, ConnectionStatus::Disconnected))
+                .show(ui, |ui| {
+                    let connection_action = ui::render_connection_settings(
+                        ui,
+                        &mut self.settings,
+                        &self.connection_status,
+                        &self.flows,
+                        &self.server_version,
+                    );
+                    
+                    match connection_action {
+                        ConnectionAction::LoadFlows => self.load_flows(ctx),
+                        ConnectionAction::TestConnection => self.test_connection(ctx),
+                        ConnectionAction::LoadKeys => self.load_keys(ctx),
+                        ConnectionAction::LoadVersion => self.load_version(ctx),
+                        ConnectionAction::None => {}
+                    }
+                });
+            
+            ui.add_space(10.0);
+            
+            // Statistics (from desktop version)
+            if !self.admin_state.keys.is_empty() {
+                ui::render_statistics(ui, &self.admin_state);
+                ui.add_space(10.0);
+            }
+            
+            // Key Management (from desktop version)
+            if !self.admin_state.keys.is_empty() {
+                egui::CollapsingHeader::new("🔑 Key Management")
+                    .default_open(true)
+                    .show(ui, |ui| {
+                        // Search and filter controls (from desktop version)
+                        ui::render_search_controls(ui, &mut self.admin_state);
+                        ui.add_space(5.0);
+                        
+                        // Bulk actions (from desktop version)
+                        let bulk_action = ui::render_bulk_actions(ui, &mut self.admin_state);
+                        match bulk_action {
+                            BulkAction::DeprecateSelected => self.bulk_deprecate(ctx),
+                            BulkAction::RestoreSelected => self.bulk_restore(ctx),
+                            BulkAction::ClearSelection => {
+                                self.admin_state.clear_selection();
+                            }
+                            BulkAction::None => {}
+                        }
+                        
+                        ui.add_space(5.0);
+                        
+                        // Keys table (from desktop version)
+                        let key_action = ui::render_keys_table(ui, &mut self.admin_state);
+                        match key_action {
+                            KeyAction::DeprecateKey(server) => self.deprecate_key(server, ctx),
+                            KeyAction::RestoreKey(server) => self.restore_key(server, ctx),
+                            KeyAction::DeleteKey(server) => self.delete_key(server, ctx),
+                            KeyAction::DeprecateServer(server) => self.deprecate_server(server, ctx),
+                            KeyAction::RestoreServer(server) => self.restore_server(server, ctx),
+                            KeyAction::None => {}
+                        }
+                    });
+                
+                ui.add_space(10.0);
+            }
+            
+            // Additional web-specific actions
+            if matches!(self.connection_status, ConnectionStatus::Connected) && !self.settings.selected_flow.is_empty() {
+                ui.horizontal(|ui| {
+                    if ui.button("🔍 Scan DNS").clicked() {
+                        self.scan_dns(ctx);
+                    }
+                    
+                    if ui.button("🔄 Refresh Keys").clicked() {
+                        self.load_keys(ctx);
+                    }
+                    
+                    ui.checkbox(&mut self.settings.auto_refresh, "Auto-refresh");
+                });
+                
+                ui.add_space(10.0);
+            }
+            
+            // Status bar (from desktop version)
+            ui.horizontal(|ui| {
+                ui.label("Status:");
+                match &self.connection_status {
+                    ConnectionStatus::Connected => {
+                        ui.colored_label(egui::Color32::GREEN, "● Connected");
+                    }
+                    ConnectionStatus::Connecting => {
+                        ui.colored_label(egui::Color32::YELLOW, "● Connecting...");
+                    }
+                    ConnectionStatus::Disconnected => {
+                        ui.colored_label(egui::Color32::GRAY, "● Disconnected");
+                    }
+                    ConnectionStatus::Error(msg) => {
+                        ui.colored_label(egui::Color32::RED, format!("● Error: {}", msg));
+                    }
+                }
+                
+                ui.separator();
+                ui.label(&self.last_operation);
+            });
+        });
+        
+        // Auto-refresh like desktop version
+        if self.settings.auto_refresh && matches!(self.connection_status, ConnectionStatus::Connected) {
+            ctx.request_repaint_after(std::time::Duration::from_secs(self.settings.refresh_interval as u64));
+        }
+    }
+}
+
+impl WebAdminApp {
+    fn handle_operation_result(&mut self, operation: AdminOperation) {
+        match operation {
+            AdminOperation::LoadFlows(result) => {
+                match result {
+                    Ok(flows) => {
+                        self.flows = flows;
+                        if !self.flows.is_empty() && self.settings.selected_flow.is_empty() {
+                            self.settings.selected_flow = self.flows[0].clone();
+                        }
+                        self.last_operation = format!("Loaded {} flows", self.flows.len());
+                    }
+                    Err(err) => {
+                        self.connection_status = ConnectionStatus::Error(err.clone());
+                        self.last_operation = format!("Failed to load flows: {}", err);
+                    }
+                }
+            }
+            AdminOperation::LoadKeys(result) => {
+                match result {
+                    Ok(keys) => {
+                        self.admin_state.keys = keys;
+                        self.admin_state.filter_keys();
+                        self.connection_status = ConnectionStatus::Connected;
+                        self.last_operation = format!("Loaded {} keys", self.admin_state.keys.len());
+                    }
+                    Err(err) => {
+                        self.connection_status = ConnectionStatus::Error(err.clone());
+                        self.last_operation = format!("Failed to load keys: {}", err);
+                    }
+                }
+            }
+            AdminOperation::TestConnection(result) => {
+                match result {
+                    Ok(msg) => {
+                        self.connection_status = ConnectionStatus::Connected;
+                        self.last_operation = msg;
+                    }
+                    Err(err) => {
+                        self.connection_status = ConnectionStatus::Error(err.clone());
+                        self.last_operation = format!("Connection failed: {}", err);
+                    }
+                }
+            }
+            AdminOperation::DeprecateKey(server, result) => {
+                match result {
+                    Ok(msg) => {
+                        self.last_operation = msg;
+                        self.load_keys_silent();
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("Failed to deprecate key for {}: {}", server, err);
+                    }
+                }
+            }
+            AdminOperation::RestoreKey(server, result) => {
+                match result {
+                    Ok(msg) => {
+                        self.last_operation = msg;
+                        self.load_keys_silent();
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("Failed to restore key for {}: {}", server, err);
+                    }
+                }
+            }
+            AdminOperation::DeleteKey(server, result) => {
+                match result {
+                    Ok(msg) => {
+                        self.last_operation = msg;
+                        self.load_keys_silent();
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("Failed to delete key for {}: {}", server, err);
+                    }
+                }
+            }
+            AdminOperation::BulkDeprecate(result) | AdminOperation::BulkRestore(result) => {
+                match result {
+                    Ok(msg) => {
+                        self.last_operation = msg;
+                        self.admin_state.clear_selection();
+                        self.load_keys_silent();
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("Bulk operation failed: {}", err);
+                    }
+                }
+            }
+            AdminOperation::ScanDns(result) => {
+                match result {
+                    Ok(results) => {
+                        let resolved = results.iter().filter(|r| r.resolved).count();
+                        let total = results.len();
+                        self.last_operation = format!("DNS scan completed: {}/{} servers resolved", resolved, total);
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("DNS scan failed: {}", err);
+                    }
+                }
+            }
+            AdminOperation::LoadVersion(result) => {
+                match result {
+                    Ok(version) => {
+                        self.server_version = Some(version.clone());
+                        self.last_operation = format!("Server version: {}", version);
+                    }
+                    Err(err) => {
+                        self.last_operation = format!("Failed to get server version: {}", err);
+                    }
+                }
+            }
+        }
+    }
+    
+    // Async operation methods - adapted from desktop version
+    fn load_flows(&mut self, _ctx: &egui::Context) {
+        self.last_operation = "Loading flows...".to_string();
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::load_flows(&settings));
+                let _ = tx.send(AdminOperation::LoadFlows(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::load_flows(&settings).await;
+                let _ = tx.send(AdminOperation::LoadFlows(result));
+            });
+        }
+    }
+    
+    fn test_connection(&mut self, _ctx: &egui::Context) {
+        self.connection_status = ConnectionStatus::Connecting;
+        self.last_operation = "Testing connection...".to_string();
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::test_connection(&settings));
+                let _ = tx.send(AdminOperation::TestConnection(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::test_connection(&settings).await;
+                let _ = tx.send(AdminOperation::TestConnection(result));
+            });
+        }
+    }
+    
+    fn load_keys(&mut self, _ctx: &egui::Context) {
+        self.admin_state.current_operation = "Loading keys...".to_string();
+        self.last_operation = "Loading keys...".to_string();
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::fetch_keys(&settings));
+                let _ = tx.send(AdminOperation::LoadKeys(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::fetch_keys(&settings).await;
+                let _ = tx.send(AdminOperation::LoadKeys(result));
+            });
+        }
+    }
+    
+    fn load_keys_silent(&mut self) {
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::fetch_keys(&settings));
+                let _ = tx.send(AdminOperation::LoadKeys(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::fetch_keys(&settings).await;
+                let _ = tx.send(AdminOperation::LoadKeys(result));
+            });
+        }
+    }
+    
+    fn deprecate_key(&mut self, server: String, _ctx: &egui::Context) {
+        self.last_operation = format!("Deprecating key for {}...", server);
+        
+        let settings = self.settings.clone();
+        let server_clone = server.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::deprecate_key(&settings, &server));
+                let _ = tx.send(AdminOperation::DeprecateKey(server_clone, result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::deprecate_key(&settings, &server).await;
+                let _ = tx.send(AdminOperation::DeprecateKey(server_clone, result));
+            });
+        }
+    }
+    
+    fn restore_key(&mut self, server: String, _ctx: &egui::Context) {
+        self.last_operation = format!("Restoring key for {}...", server);
+        
+        let settings = self.settings.clone();
+        let server_clone = server.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::restore_key(&settings, &server));
+                let _ = tx.send(AdminOperation::RestoreKey(server_clone, result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::restore_key(&settings, &server).await;
+                let _ = tx.send(AdminOperation::RestoreKey(server_clone, result));
+            });
+        }
+    }
+    
+    fn delete_key(&mut self, server: String, _ctx: &egui::Context) {
+        self.last_operation = format!("Deleting key for {}...", server);
+        
+        let settings = self.settings.clone();
+        let server_clone = server.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::delete_key(&settings, &server));
+                let _ = tx.send(AdminOperation::DeleteKey(server_clone, result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::delete_key(&settings, &server).await;
+                let _ = tx.send(AdminOperation::DeleteKey(server_clone, result));
+            });
+        }
+    }
+    
+    fn deprecate_server(&mut self, server: String, ctx: &egui::Context) {
+        self.deprecate_key(server, ctx);
+    }
+    
+    fn restore_server(&mut self, server: String, ctx: &egui::Context) {
+        self.restore_key(server, ctx);
+    }
+    
+    fn bulk_deprecate(&mut self, _ctx: &egui::Context) {
+        let servers = self.admin_state.get_selected_servers();
+        if servers.is_empty() {
+            return;
+        }
+        
+        self.last_operation = format!("Bulk deprecating {} servers...", servers.len());
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::bulk_deprecate_servers(&settings, servers));
+                let _ = tx.send(AdminOperation::BulkDeprecate(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::bulk_deprecate_servers(&settings, servers).await;
+                let _ = tx.send(AdminOperation::BulkDeprecate(result));
+            });
+        }
+    }
+    
+    fn bulk_restore(&mut self, _ctx: &egui::Context) {
+        let servers = self.admin_state.get_selected_servers();
+        if servers.is_empty() {
+            return;
+        }
+        
+        self.last_operation = format!("Bulk restoring {} servers...", servers.len());
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::bulk_restore_servers(&settings, servers));
+                let _ = tx.send(AdminOperation::BulkRestore(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::bulk_restore_servers(&settings, servers).await;
+                let _ = tx.send(AdminOperation::BulkRestore(result));
+            });
+        }
+    }
+    
+    fn scan_dns(&mut self, _ctx: &egui::Context) {
+        self.last_operation = "Scanning DNS resolution...".to_string();
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::scan_dns_resolution(&settings));
+                let _ = tx.send(AdminOperation::ScanDns(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::scan_dns_resolution(&settings).await;
+                let _ = tx.send(AdminOperation::ScanDns(result));
+            });
+        }
+    }
+    
+    fn load_version(&mut self, _ctx: &egui::Context) {
+        self.last_operation = "Loading server version...".to_string();
+        
+        let settings = self.settings.clone();
+        let (tx, rx) = mpsc::channel();
+        self.operation_receiver = Some(rx);
+        
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                let result = rt.block_on(api::get_version(&settings));
+                let _ = tx.send(AdminOperation::LoadVersion(result));
+            });
+        }
+        
+        #[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+        {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = api::get_version(&settings).await;
+                let _ = tx.send(AdminOperation::LoadVersion(result));
+            });
+        }
+    }
+}
--- a/src/web_gui/state.rs
+++ b/src/web_gui/state.rs
@@ -0,0 +1,182 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AdminSettings {
+    pub server_url: String,
+    pub basic_auth: String,
+    pub selected_flow: String,
+    pub auto_refresh: bool,
+    pub refresh_interval: u32,
+}
+
+impl Default for AdminSettings {
+    fn default() -> Self {
+        Self {
+            server_url: String::new(),
+            basic_auth: String::new(),
+            selected_flow: String::new(),
+            auto_refresh: false,
+            refresh_interval: 30,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AdminState {
+    pub keys: Vec<SshKey>,
+    pub filtered_keys: Vec<SshKey>,
+    pub search_term: String,
+    pub show_deprecated_only: bool,
+    pub selected_servers: HashMap<String, bool>,
+    pub expanded_servers: HashMap<String, bool>,
+    pub current_operation: String,
+}
+
+impl Default for AdminState {
+    fn default() -> Self {
+        Self {
+            keys: Vec::new(),
+            filtered_keys: Vec::new(),
+            search_term: String::new(),
+            show_deprecated_only: false,
+            selected_servers: HashMap::new(),
+            expanded_servers: HashMap::new(),
+            current_operation: "Ready".to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SshKey {
+    pub server: String,
+    pub public_key: String,
+    #[serde(default)]
+    pub deprecated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ConnectionStatus {
+    Disconnected,
+    Connecting,
+    Connected,
+    Error(String),
+}
+
+impl PartialEq for ConnectionStatus {
+    fn eq(&self, other: &Self) -> bool {
+        std::mem::discriminant(self) == std::mem::discriminant(other)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum AdminOperation {
+    LoadKeys(Result<Vec<SshKey>, String>),
+    LoadFlows(Result<Vec<String>, String>),
+    DeprecateKey(String, Result<String, String>),
+    RestoreKey(String, Result<String, String>),
+    DeleteKey(String, Result<String, String>),
+    BulkDeprecate(Result<String, String>),
+    BulkRestore(Result<String, String>),
+    TestConnection(Result<String, String>),
+    ScanDns(Result<Vec<DnsResult>, String>),
+    LoadVersion(Result<String, String>),
+}
+
+// Re-export DnsResolutionResult from web.rs for consistency
+pub use crate::web::DnsResolutionResult as DnsResult;
+
+impl AdminState {
+    /// Filter keys based on search term and deprecated filter
+    pub fn filter_keys(&mut self) {
+        let mut filtered = self.keys.clone();
+        
+        // Apply deprecated filter
+        if self.show_deprecated_only {
+            filtered.retain(|key| key.deprecated);
+        }
+        
+        // Apply search filter
+        if !self.search_term.is_empty() {
+            let search_term = self.search_term.to_lowercase();
+            filtered.retain(|key| {
+                key.server.to_lowercase().contains(&search_term)
+                    || key.public_key.to_lowercase().contains(&search_term)
+            });
+        }
+        
+        self.filtered_keys = filtered;
+    }
+    
+    /// Get selected servers list
+    pub fn get_selected_servers(&self) -> Vec<String> {
+        self.selected_servers
+            .iter()
+            .filter_map(|(server, &selected)| {
+                if selected { Some(server.clone()) } else { None }
+            })
+            .collect()
+    }
+    
+    /// Clear selection
+    pub fn clear_selection(&mut self) {
+        self.selected_servers.clear();
+    }
+    
+    /// Get statistics
+    pub fn get_statistics(&self) -> AdminStatistics {
+        let total_keys = self.keys.len();
+        let active_keys = self.keys.iter().filter(|k| !k.deprecated).count();
+        let deprecated_keys = total_keys - active_keys;
+        let unique_servers = self.keys
+            .iter()
+            .map(|k| &k.server)
+            .collect::<std::collections::HashSet<_>>()
+            .len();
+            
+        AdminStatistics {
+            total_keys,
+            active_keys,
+            deprecated_keys,
+            unique_servers,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AdminStatistics {
+    pub total_keys: usize,
+    pub active_keys: usize,
+    pub deprecated_keys: usize,
+    pub unique_servers: usize,
+}
+
+/// Get SSH key type from public key string
+pub fn get_key_type(public_key: &str) -> String {
+    if public_key.starts_with("ssh-rsa") {
+        "RSA".to_string()
+    } else if public_key.starts_with("ssh-ed25519") {
+        "ED25519".to_string()
+    } else if public_key.starts_with("ecdsa-sha2-nistp") {
+        "ECDSA".to_string()
+    } else if public_key.starts_with("ssh-dss") {
+        "DSA".to_string()
+    } else {
+        "Unknown".to_string()
+    }
+}
+
+/// Get preview of SSH key (first 16 characters of key part)
+pub fn get_key_preview(public_key: &str) -> String {
+    let parts: Vec<&str> = public_key.split_whitespace().collect();
+    if parts.len() >= 2 {
+        let key_part = parts[1];
+        if key_part.len() > 16 {
+            format!("{}...", &key_part[..16])
+        } else {
+            key_part.to_string()
+        }
+    } else {
+        format!("{}...", &public_key[..std::cmp::min(16, public_key.len())])
+    }
+}
--- a/src/web_gui/ui.rs
+++ b/src/web_gui/ui.rs
@@ -0,0 +1,532 @@
+use super::state::{AdminState, AdminSettings, ConnectionStatus, get_key_type, get_key_preview};
+use eframe::egui;
+use std::collections::BTreeMap;
+
+#[derive(Debug, Clone)]
+pub enum KeyAction {
+    None,
+    DeprecateKey(String),
+    RestoreKey(String),
+    DeleteKey(String),
+    DeprecateServer(String),
+    RestoreServer(String),
+}
+
+#[derive(Debug, Clone)]
+pub enum BulkAction {
+    None,
+    DeprecateSelected,
+    RestoreSelected,
+    ClearSelection,
+}
+
+/// Render connection settings panel
+pub fn render_connection_settings(
+    ui: &mut egui::Ui,
+    settings: &mut AdminSettings,
+    connection_status: &ConnectionStatus,
+    flows: &[String],
+    server_version: &Option<String>,
+) -> ConnectionAction {
+    let mut action = ConnectionAction::None;
+    
+    ui.group(|ui| {
+        ui.set_min_width(ui.available_width());
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new("⚙️ Connection Settings").size(16.0).strong());
+            ui.add_space(8.0);
+            
+            // Server URL
+            ui.horizontal(|ui| {
+                ui.label("Server URL:");
+                ui.text_edit_singleline(&mut settings.server_url);
+            });
+            
+            // Basic Auth
+            ui.horizontal(|ui| {
+                ui.label("Basic Auth:");
+                ui.add(egui::TextEdit::singleline(&mut settings.basic_auth).password(true));
+            });
+            
+            // Flow selection
+            ui.horizontal(|ui| {
+                ui.label("Flow:");
+                egui::ComboBox::from_id_salt("flow_select")
+                    .selected_text(&settings.selected_flow)
+                    .show_ui(ui, |ui| {
+                        for flow in flows {
+                            ui.selectable_value(&mut settings.selected_flow, flow.clone(), flow);
+                        }
+                    });
+            });
+            
+            // Connection status
+            ui.horizontal(|ui| {
+                ui.label("Status:");
+                match connection_status {
+                    ConnectionStatus::Connected => {
+                        ui.colored_label(egui::Color32::GREEN, "● Connected");
+                    }
+                    ConnectionStatus::Connecting => {
+                        ui.colored_label(egui::Color32::YELLOW, "● Connecting...");
+                    }
+                    ConnectionStatus::Disconnected => {
+                        ui.colored_label(egui::Color32::GRAY, "● Disconnected");
+                    }
+                    ConnectionStatus::Error(msg) => {
+                        ui.colored_label(egui::Color32::RED, format!("● Error: {}", msg));
+                    }
+                }
+            });
+            
+            // Server version display
+            if let Some(version) = server_version {
+                ui.horizontal(|ui| {
+                    ui.label("Server Version:");
+                    ui.colored_label(egui::Color32::LIGHT_BLUE, version);
+                });
+            }
+            
+            ui.add_space(8.0);
+            
+            // Action buttons
+            ui.horizontal(|ui| {
+                if ui.button("Load Flows").clicked() {
+                    action = ConnectionAction::LoadFlows;
+                }
+                
+                if ui.button("Test Connection").clicked() {
+                    action = ConnectionAction::TestConnection;
+                }
+                
+                if ui.button("Get Version").clicked() {
+                    action = ConnectionAction::LoadVersion;
+                }
+                
+                if !settings.selected_flow.is_empty() && ui.button("Load Keys").clicked() {
+                    action = ConnectionAction::LoadKeys;
+                }
+            });
+        });
+    });
+    
+    action
+}
+
+/// Render statistics cards
+pub fn render_statistics(ui: &mut egui::Ui, admin_state: &AdminState) {
+    let stats = admin_state.get_statistics();
+    
+    ui.group(|ui| {
+        ui.set_min_width(ui.available_width());
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new("📊 Statistics").size(16.0).strong());
+            ui.add_space(8.0);
+            
+            ui.horizontal(|ui| {
+                ui.columns(4, |cols| {
+                    // Total keys
+                    cols[0].vertical_centered_justified(|ui| {
+                        ui.label(egui::RichText::new("📊").size(20.0));
+                        ui.label(
+                            egui::RichText::new(stats.total_keys.to_string())
+                                .size(24.0)
+                                .strong(),
+                        );
+                        ui.label(
+                            egui::RichText::new("Total Keys")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
+                    });
+                    
+                    // Active keys
+                    cols[1].vertical_centered_justified(|ui| {
+                        ui.label(egui::RichText::new("✅").size(20.0));
+                        ui.label(
+                            egui::RichText::new(stats.active_keys.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_GREEN),
+                        );
+                        ui.label(
+                            egui::RichText::new("Active")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
+                    });
+                    
+                    // Deprecated keys
+                    cols[2].vertical_centered_justified(|ui| {
+                        ui.label(egui::RichText::new("❌").size(20.0));
+                        ui.label(
+                            egui::RichText::new(stats.deprecated_keys.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_RED),
+                        );
+                        ui.label(
+                            egui::RichText::new("Deprecated")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
+                    });
+                    
+                    // Servers
+                    cols[3].vertical_centered_justified(|ui| {
+                        ui.label(egui::RichText::new("💻").size(20.0));
+                        ui.label(
+                            egui::RichText::new(stats.unique_servers.to_string())
+                                .size(24.0)
+                                .strong()
+                                .color(egui::Color32::LIGHT_BLUE),
+                        );
+                        ui.label(
+                            egui::RichText::new("Servers")
+                                .size(11.0)
+                                .color(egui::Color32::GRAY),
+                        );
+                    });
+                });
+            });
+        });
+    });
+}
+
+/// Render search and filter controls
+pub fn render_search_controls(ui: &mut egui::Ui, admin_state: &mut AdminState) -> bool {
+    let mut changed = false;
+    
+    ui.group(|ui| {
+        ui.set_min_width(ui.available_width());
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new("🔍 Search & Filter").size(16.0).strong());
+            ui.add_space(8.0);
+            
+            // Search field
+            ui.horizontal(|ui| {
+                ui.label("Search:");
+                let search_response = ui.add_sized(
+                    [ui.available_width() * 0.6, 20.0],
+                    egui::TextEdit::singleline(&mut admin_state.search_term)
+                        .hint_text("Search servers or keys..."),
+                );
+                
+                if search_response.changed() {
+                    changed = true;
+                }
+                
+                if !admin_state.search_term.is_empty() {
+                    if ui.small_button("Clear").clicked() {
+                        admin_state.search_term.clear();
+                        changed = true;
+                    }
+                }
+            });
+            
+            ui.add_space(5.0);
+            
+            // Filter controls
+            ui.horizontal(|ui| {
+                ui.label("Filter:");
+                let show_deprecated = admin_state.show_deprecated_only;
+                if ui.selectable_label(!show_deprecated, "✅ Active").clicked() {
+                    admin_state.show_deprecated_only = false;
+                    changed = true;
+                }
+                if ui.selectable_label(show_deprecated, "❗ Deprecated").clicked() {
+                    admin_state.show_deprecated_only = true;
+                    changed = true;
+                }
+            });
+        });
+    });
+    
+    if changed {
+        admin_state.filter_keys();
+    }
+    
+    changed
+}
+
+/// Render bulk actions controls
+pub fn render_bulk_actions(ui: &mut egui::Ui, admin_state: &mut AdminState) -> BulkAction {
+    let selected_count = admin_state
+        .selected_servers
+        .values()
+        .filter(|&&v| v)
+        .count();
+        
+    if selected_count == 0 {
+        return BulkAction::None;
+    }
+    
+    let mut action = BulkAction::None;
+    
+    ui.group(|ui| {
+        ui.set_min_width(ui.available_width());
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                ui.label(egui::RichText::new("📋").size(14.0));
+                ui.label(
+                    egui::RichText::new(format!("Selected {} servers", selected_count))
+                        .size(14.0)
+                        .strong()
+                        .color(egui::Color32::LIGHT_BLUE),
+                );
+            });
+            
+            ui.add_space(5.0);
+            
+            ui.horizontal(|ui| {
+                if ui.button("❗ Deprecate Selected").clicked() {
+                    action = BulkAction::DeprecateSelected;
+                }
+                
+                if ui.button("✅ Restore Selected").clicked() {
+                    action = BulkAction::RestoreSelected;
+                }
+                
+                if ui.button("Clear Selection").clicked() {
+                    action = BulkAction::ClearSelection;
+                }
+            });
+        });
+    });
+    
+    action
+}
+
+/// Render keys table grouped by servers
+pub fn render_keys_table(ui: &mut egui::Ui, admin_state: &mut AdminState) -> KeyAction {
+    if admin_state.filtered_keys.is_empty() {
+        render_empty_state(ui, admin_state);
+        return KeyAction::None;
+    }
+    
+    let mut action = KeyAction::None;
+    
+    // Group keys by server
+    let mut servers: BTreeMap<String, Vec<&crate::web_gui::state::SshKey>> = BTreeMap::new();
+    for key in &admin_state.filtered_keys {
+        servers
+            .entry(key.server.clone())
+            .or_insert_with(Vec::new)
+            .push(key);
+    }
+    
+    // Render each server group
+    egui::ScrollArea::vertical().show(ui, |ui| {
+        for (server_name, server_keys) in servers {
+            let is_expanded = admin_state
+                .expanded_servers
+                .get(&server_name)
+                .copied()
+                .unwrap_or(false);
+            let active_count = server_keys.iter().filter(|k| !k.deprecated).count();
+            let deprecated_count = server_keys.len() - active_count;
+            
+            // Server header
+            ui.group(|ui| {
+                ui.horizontal(|ui| {
+                    // Server selection checkbox
+                    let mut selected = admin_state
+                        .selected_servers
+                        .get(&server_name)
+                        .copied()
+                        .unwrap_or(false);
+                    if ui.checkbox(&mut selected, "").changed() {
+                        admin_state
+                            .selected_servers
+                            .insert(server_name.clone(), selected);
+                    }
+                    
+                    // Expand/collapse button
+                    let expand_icon = if is_expanded { "▼" } else { "▶" };
+                    if ui.small_button(expand_icon).clicked() {
+                        admin_state
+                            .expanded_servers
+                            .insert(server_name.clone(), !is_expanded);
+                    }
+                    
+                    // Server icon and name
+                    ui.label(egui::RichText::new("💻").size(16.0));
+                    ui.label(
+                        egui::RichText::new(&server_name)
+                            .size(15.0)
+                            .strong(),
+                    );
+                    
+                    // Keys count badge
+                    ui.label(format!("({} keys)", server_keys.len()));
+                    
+                    // Deprecated count badge
+                    if deprecated_count > 0 {
+                        ui.colored_label(
+                            egui::Color32::RED,
+                            format!("{} deprecated", deprecated_count)
+                        );
+                    }
+                    
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                        // Server action buttons
+                        if deprecated_count > 0 {
+                            if ui.small_button("✅ Restore").clicked() {
+                                action = KeyAction::RestoreServer(server_name.clone());
+                            }
+                        }
+                        
+                        if active_count > 0 {
+                            if ui.small_button("❗ Deprecate").clicked() {
+                                action = KeyAction::DeprecateServer(server_name.clone());
+                            }
+                        }
+                    });
+                });
+            });
+            
+            // Expanded key details
+            if is_expanded {
+                ui.indent(&server_name, |ui| {
+                    for key in &server_keys {
+                        if let Some(key_action) = render_key_item(ui, key, &server_name) {
+                            action = key_action;
+                        }
+                    }
+                });
+            }
+            
+            ui.add_space(5.0);
+        }
+    });
+    
+    action
+}
+
+/// Render empty state when no keys are available
+fn render_empty_state(ui: &mut egui::Ui, admin_state: &AdminState) {
+    ui.vertical_centered(|ui| {
+        ui.add_space(60.0);
+        if admin_state.keys.is_empty() {
+            ui.label(
+                egui::RichText::new("🔑")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No SSH keys available")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("Keys will appear here once loaded from the server")
+                    .size(14.0)
+                    .color(egui::Color32::DARK_GRAY),
+            );
+        } else if !admin_state.search_term.is_empty() {
+            ui.label(
+                egui::RichText::new("🔍")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No results found")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new(format!(
+                    "Try adjusting your search: '{}'",
+                    admin_state.search_term
+                ))
+                .size(14.0)
+                .color(egui::Color32::DARK_GRAY),
+            );
+        } else {
+            ui.label(
+                egui::RichText::new("❌")
+                    .size(48.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("No keys match current filters")
+                    .size(18.0)
+                    .color(egui::Color32::GRAY),
+            );
+            ui.label(
+                egui::RichText::new("Try adjusting your search or filter settings")
+                    .size(14.0)
+                    .color(egui::Color32::DARK_GRAY),
+            );
+        }
+    });
+}
+
+/// Render individual key item
+fn render_key_item(
+    ui: &mut egui::Ui,
+    key: &crate::web_gui::state::SshKey,
+    server_name: &str,
+) -> Option<KeyAction> {
+    let mut action = None;
+    
+    ui.group(|ui| {
+        ui.horizontal(|ui| {
+            // Key type badge
+            let key_type = get_key_type(&key.public_key);
+            let badge_color = match key_type.as_str() {
+                "RSA" => egui::Color32::from_rgb(52, 144, 220),
+                "ED25519" => egui::Color32::from_rgb(46, 204, 113),
+                "ECDSA" => egui::Color32::from_rgb(241, 196, 15),
+                "DSA" => egui::Color32::from_rgb(230, 126, 34),
+                _ => egui::Color32::GRAY,
+            };
+            
+            ui.colored_label(badge_color, &key_type);
+            ui.add_space(5.0);
+            
+            // Status badge
+            if key.deprecated {
+                ui.colored_label(egui::Color32::RED, "❗ DEPRECATED");
+            } else {
+                ui.colored_label(egui::Color32::GREEN, "✅ ACTIVE");
+            }
+            
+            ui.add_space(5.0);
+            
+            // Key preview
+            ui.monospace(get_key_preview(&key.public_key));
+            
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                // Key action buttons
+                if key.deprecated {
+                    if ui.small_button("Restore").clicked() {
+                        action = Some(KeyAction::RestoreKey(server_name.to_string()));
+                    }
+                    if ui.small_button("Delete").clicked() {
+                        action = Some(KeyAction::DeleteKey(server_name.to_string()));
+                    }
+                } else {
+                    if ui.small_button("Deprecate").clicked() {
+                        action = Some(KeyAction::DeprecateKey(server_name.to_string()));
+                    }
+                }
+                
+                if ui.small_button("Copy").clicked() {
+                    ui.output_mut(|o| o.copied_text = key.public_key.clone());
+                }
+            });
+        });
+    });
+    
+    action
+}
+
+#[derive(Debug, Clone)]
+pub enum ConnectionAction {
+    None,
+    LoadFlows,
+    TestConnection,
+    LoadKeys,
+    LoadVersion,
+}
--- a/src/web_gui/wasm.rs
+++ b/src/web_gui/wasm.rs
@@ -0,0 +1,43 @@
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use wasm_bindgen::prelude::*;
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use super::app::WebAdminApp;
+
+/// WASM entry point for the web admin application
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+#[wasm_bindgen]
+pub fn start_web_admin(canvas_id: &str) -> Result<(), JsValue> {
+    // Setup console logging for WASM
+    console_error_panic_hook::set_once();
+    tracing_wasm::set_as_global_default();
+    
+    let web_options = eframe::WebOptions::default();
+    let canvas_id = canvas_id.to_string();
+    
+    wasm_bindgen_futures::spawn_local(async move {
+        let app = WebAdminApp::default();
+        
+        let result = eframe::WebRunner::new()
+            .start(
+                &canvas_id,
+                web_options,
+                Box::new(|_cc| Ok(Box::new(app))),
+            )
+            .await;
+            
+        match result {
+            Ok(_) => web_sys::console::log_1(&"eframe started successfully".into()),
+            Err(e) => web_sys::console::error_1(&format!("Failed to start eframe: {:?}", e).into()),
+        }
+    });
+    
+    Ok(())
+}
+
+/// Initialize the WASM module
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+#[wasm_bindgen(start)]
+pub fn wasm_main() {
+    console_error_panic_hook::set_once();
+}
--- a/src/web_gui/wasm_api.rs
+++ b/src/web_gui/wasm_api.rs
@@ -0,0 +1,131 @@
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use super::state::{SshKey, DnsResult, AdminSettings};
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use wasm_bindgen::prelude::*;
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use wasm_bindgen_futures::JsFuture;
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+use web_sys::{Request, RequestInit, RequestMode, Response};
+
+/// Simplified API for WASM - uses browser fetch API
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn test_connection(settings: &AdminSettings) -> Result<String, String> {
+    let url = format!("{}/{}/keys", settings.server_url.trim_end_matches('/'), settings.selected_flow);
+    
+    let response = fetch_json(&url).await?;
+    let keys: Result<Vec<SshKey>, _> = serde_json::from_str(&response);
+    
+    match keys {
+        Ok(keys) => Ok(format!("Connection successful! Found {} SSH keys from flow '{}'", keys.len(), settings.selected_flow)),
+        Err(e) => Err(format!("Failed to parse response: {}", e)),
+    }
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn load_flows(settings: &AdminSettings) -> Result<Vec<String>, String> {
+    let url = format!("{}/api/flows", settings.server_url.trim_end_matches('/'));
+    
+    let response = fetch_json(&url).await?;
+    let flows: Result<Vec<String>, _> = serde_json::from_str(&response);
+    
+    flows.map_err(|e| format!("Failed to parse flows: {}", e))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn fetch_keys(settings: &AdminSettings) -> Result<Vec<SshKey>, String> {
+    let url = format!("{}/{}/keys", settings.server_url.trim_end_matches('/'), settings.selected_flow);
+    
+    let response = fetch_json(&url).await?;
+    let keys: Result<Vec<SshKey>, _> = serde_json::from_str(&response);
+    
+    keys.map_err(|e| format!("Failed to parse keys: {}", e))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn get_version(settings: &AdminSettings) -> Result<String, String> {
+    let url = format!("{}/api/version", settings.server_url.trim_end_matches('/'));
+    
+    let response = fetch_json(&url).await?;
+    let version_response: Result<serde_json::Value, _> = serde_json::from_str(&response);
+    
+    match version_response {
+        Ok(data) => {
+            let version = data.get("version")
+                .and_then(|v| v.as_str())
+                .unwrap_or("unknown")
+                .to_string();
+            Ok(version)
+        }
+        Err(e) => Err(format!("Failed to parse version: {}", e)),
+    }
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn deprecate_key(_settings: &AdminSettings, server: &str) -> Result<String, String> {
+    Ok(format!("WASM: Would deprecate key for {}", server))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn restore_key(_settings: &AdminSettings, server: &str) -> Result<String, String> {
+    Ok(format!("WASM: Would restore key for {}", server))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn delete_key(_settings: &AdminSettings, server: &str) -> Result<String, String> {
+    Ok(format!("WASM: Would delete key for {}", server))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn bulk_deprecate_servers(_settings: &AdminSettings, servers: Vec<String>) -> Result<String, String> {
+    Ok(format!("WASM: Would bulk deprecate {} servers", servers.len()))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn bulk_restore_servers(_settings: &AdminSettings, servers: Vec<String>) -> Result<String, String> {
+    Ok(format!("WASM: Would bulk restore {} servers", servers.len()))
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+pub async fn scan_dns_resolution(_settings: &AdminSettings) -> Result<Vec<DnsResult>, String> {
+    Ok(vec![
+        DnsResult {
+            server: "demo-server".to_string(),
+            resolved: true,
+            error: None,
+        }
+    ])
+}
+
+/// Helper function to make HTTP requests using browser's fetch API
+#[cfg(all(target_arch = "wasm32", feature = "web-gui"))]
+async fn fetch_json(url: &str) -> Result<String, String> {
+    let window = web_sys::window().ok_or("No window object")?;
+    
+    let mut opts = RequestInit::new();
+    opts.method("GET");
+    opts.mode(RequestMode::Cors);
+    
+    let request = Request::new_with_str_and_init(url, &opts)
+        .map_err(|e| format!("Failed to create request: {:?}", e))?;
+    
+    let resp_value = JsFuture::from(window.fetch_with_request(&request))
+        .await
+        .map_err(|e| format!("Request failed: {:?}", e))?;
+    
+    let resp: Response = resp_value.dyn_into()
+        .map_err(|e| format!("Failed to cast response: {:?}", e))?;
+    
+    if !resp.ok() {
+        return Err(format!("HTTP error: {} {}", resp.status(), resp.status_text()));
+    }
+    
+    let text_promise = resp.text()
+        .map_err(|e| format!("Failed to get text promise: {:?}", e))?;
+    
+    let text_value = JsFuture::from(text_promise)
+        .await
+        .map_err(|e| format!("Failed to get text: {:?}", e))?;
+    
+    text_value.as_string()
+        .ok_or("Response is not a string".to_string())
+}
Author	SHA1	Message	Date
Alexandr Bogomiakov	0d35beac1f	web wasm ui	2025-07-24 08:34:53 +03:00
Alexandr Bogomiakov	8af35dca4f	web wasm ui	2025-07-24 08:24:51 +03:00
Alexandr Bogomiakov	626b152227	Split cli and gui bins	2025-07-24 05:10:41 +03:00
Alexandr Bogomiakov	828bb74780	Split cli and gui bins	2025-07-24 05:01:04 +03:00
Alexandr Bogomiakov	dd8f895d8a	Split cli and gui bins	2025-07-24 04:50:08 +03:00
Alexandr Bogomiakov	f0e3ca35ba	Split cli and gui bins	2025-07-24 04:38:47 +03:00
Alexandr Bogomiakov	98520a9a50	Fixed tray icon on linux	2025-07-24 04:20:36 +03:00
Alexandr Bogomiakov	66c9753fc3	Fixed tray icon on linux	2025-07-24 04:16:10 +03:00
Alexandr Bogomiakov	f4eb46afce	Fixed tray icon on linux	2025-07-24 04:04:15 +03:00
Alexandr Bogomiakov	3cc326e8dc	Fixed tray icon on linux	2025-07-24 03:54:13 +03:00
Alexandr Bogomiakov	6bc817172d	Fix Release action	2025-07-24 03:29:36 +03:00
Alexandr Bogomiakov	18db65c612	Fix Release action	2025-07-24 03:22:54 +03:00
Alexandr Bogomiakov	cb40370c83	Fix Release action	2025-07-24 03:18:59 +03:00
Alexandr Bogomiakov	2afe56934f	Fix Release action	2025-07-24 03:16:14 +03:00
Alexandr Bogomiakov	aab258f45b	Fix Release action	2025-07-24 03:12:09 +03:00
Alexandr Bogomiakov	6825f1fff6	Fix Release action	2025-07-24 03:11:53 +03:00
Alexandr Bogomiakov	fcc1f76d70	Fixed windows start console	2025-07-24 02:36:21 +03:00
Alexandr Bogomiakov	fbadd66d12	Fixed windows start console	2025-07-24 02:11:27 +03:00
Alexandr Bogomiakov	ebb0967bc9	Fix Release action	2025-07-24 01:32:52 +03:00
Alexandr Bogomiakov	774af5a269	Fix Release action	2025-07-24 01:26:06 +03:00
Alexandr Bogomiakov	b74667bcfa	Fix Release action	2025-07-24 01:18:17 +03:00
Alexandr Bogomiakov	fe79905de5	Fix Release action	2025-07-24 01:12:34 +03:00
Alexandr Bogomiakov	e5ac8fbc02	Disabled musl build	2025-07-24 00:58:35 +03:00
Alexandr Bogomiakov	b8d78ac481	Disabled musl build	2025-07-24 00:57:42 +03:00
Alexandr Bogomiakov	b322299054	Fix musl build	2025-07-24 00:44:48 +03:00
Alexandr Bogomiakov	8387b8c84b	Fix musl build	2025-07-24 00:42:28 +03:00
Alexandr Bogomiakov	9b6c64e2f1	Fix GUI feature declaration	2025-07-24 00:35:13 +03:00
Alexandr Bogomiakov	3161e6f08d	Drop ui check CI	2025-07-24 00:15:42 +03:00
Alexandr Bogomiakov	f5d6afc29c	Drop ui check CI	2025-07-24 00:13:21 +03:00
Alexandr Bogomiakov	3a1c6ff072	Fix musl build	2025-07-24 00:12:37 +03:00
Alexandr Bogomiakov	43db14196a	Fixed build workflow	2025-07-24 00:01:49 +03:00
Alexandr Bogomiakov	977d67cbf0	Fixed build workflow	2025-07-23 23:53:46 +03:00
Alexandr Bogomiakov	201d008d81	Build fixes Some checks failed UI Branch Build Check / Build Check (x86_64-unknown-linux-musl, ubuntu-latest) (push) Failing after 2m46s Details UI Branch Build Check / Build Check (aarch64-apple-darwin, macos-latest) (push) Has been cancelled Details UI Branch Build Check / Build Check (x86_64-pc-windows-msvc, windows-latest) (push) Has been cancelled Details	2025-07-23 15:45:51 +03:00
Alexandr Bogomiakov	04ae4078d1	Build fixes	2025-07-23 15:41:00 +03:00
Alexandr Bogomiakov	b8d6b18cde	Build fixes	2025-07-23 15:38:35 +03:00
Alexandr Bogomiakov	02c7de174e	Build fixes	2025-07-23 15:34:10 +03:00
Alexandr Bogomiakov	551d639e08	Build fixes	2025-07-23 15:13:36 +03:00
Alexandr Bogomiakov	66542edc4b	Build fixes	2025-07-23 15:10:06 +03:00
Alexandr Bogomiakov	22db2d0ab1	Build fixes	2025-07-23 15:06:31 +03:00
Alexandr Bogomiakov	821b3024ba	Build fixes	2025-07-23 14:54:33 +03:00
Alexandr Bogomiakov	c23b3a8531	Build fixes	2025-07-23 14:47:58 +03:00
Ultradesu	cba8c58af7	UI code reworked	2025-07-22 23:14:55 +03:00
Ultradesu	7cc446d227	UI code reworked	2025-07-22 20:10:44 +03:00
Ultradesu	c342134f03	UI code reworked	2025-07-22 18:06:48 +03:00
Ultradesu	c69803ca3d	Operations log	2025-07-22 17:43:12 +03:00
Ultradesu	f6e3ad8558	Fix watcher	2025-07-22 17:41:48 +03:00
Ultradesu	6012728644	Fix watcher	2025-07-22 17:38:37 +03:00
Ultradesu	fa6c6b0203	Fix watcher	2025-07-22 17:33:15 +03:00
Ultradesu	cd6373d78a	Fix watcher	2025-07-22 17:29:08 +03:00
Ultradesu	6ad3cd8f23	Fix watcher	2025-07-22 17:27:19 +03:00
Ultradesu	6dc0f279b2	Fix watcher	2025-07-22 16:36:44 +03:00
Ultradesu	d604bb8119	GUI Feature	2025-07-22 16:20:39 +03:00
Ultradesu	2e5cf1ca29	Fixed button colors	2025-07-22 15:21:30 +03:00
Ultradesu	567e744247	Added egui admin	2025-07-22 14:48:47 +03:00
Ultradesu	cd9c10f2dd	Added tooltip	2025-07-22 14:22:57 +03:00
Ultradesu	c6099f4569	Egui WOrks fIne	2025-07-22 14:12:09 +03:00
Ultradesu	ad3dfeee34	Works with egui	2025-07-22 13:44:54 +03:00
Ultradesu	8b920596e5	Works with egui	2025-07-22 13:44:39 +03:00
Ultradesu	a3a96eebce	works with macos native ui	2025-07-22 13:02:22 +03:00
Ultradesu	9d3d52f38a	works with macos native ui	2025-07-22 12:50:56 +03:00
Ultradesu	07ff4454d2	works with macos native ui	2025-07-22 12:50:01 +03:00