Claudette

Claude's missing better half — a companion tool for Claude Code usage.

Claudette is a cross-platform desktop application built with Tauri 2 (Rust backend) and React/TypeScript (frontend). It provides a lightweight interface for managing and orchestrating Claude Code sessions, similar in spirit to Conductor.build but with a focused feature set.

Prerequisites

• Rust (stable toolchain, edition 2024)
• Bun (JavaScript runtime and package manager)
• Tauri CLI: cargo install tauri-cli --version "^2"
• Platform dependencies for Tauri:
  • macOS: Xcode Command Line Tools (xcode-select --install)
  • Linux: System libraries for WebKitGTK. On Debian/Ubuntu:

    sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file \
      libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev
    

Getting started

# Install frontend dependencies
cd src/ui && bun install && cd ../..

# Run in development mode (hot-reload)
cargo tauri dev

# Build optimized release binary
cargo tauri build

# Run backend tests
cargo test --all-features

# Lint
cargo clippy --workspace --all-targets

# Check frontend types
cd src/ui && bunx tsc --noEmit

Project structure

Cargo.toml              # Workspace root + claudette lib crate
src/
  lib.rs                # Backend library entry point
  db.rs                 # SQLite database (rusqlite)
  git.rs                # Async git operations
  diff.rs               # Diff parsing
  agent.rs              # Claude CLI subprocess + streaming
  model/                # Data types
  names/                # Random workspace name generator
  ui/                   # React/Vite frontend
    src/
      components/       # UI components (sidebar, chat, diff, terminal, modals)
      hooks/            # Tauri event listeners
      stores/           # Zustand state management
      services/         # Typed Tauri IPC wrappers
      types/            # TypeScript types matching Rust models
src-tauri/
  Cargo.toml            # Tauri binary crate
  tauri.conf.json       # Tauri configuration
  src/
    main.rs             # Tauri entry point
    commands/           # #[tauri::command] handlers
    state.rs            # Managed application state
    pty.rs              # Terminal PTY management
    transport/          # Remote transport trait + WebSocket client
    remote.rs           # Remote connection manager
    mdns.rs             # mDNS service browser
src-server/
  Cargo.toml            # Headless server binary crate
  src/
    main.rs             # CLI entry point (clap)
    ws.rs               # WebSocket accept loop + per-connection handler
    handler.rs          # JSON-RPC command dispatcher
    tls.rs              # Self-signed TLS certificate management
    auth.rs             # Pairing token + session token auth
    mdns.rs             # mDNS service advertisement

Shell integration (optional)

Claudette can track terminal commands and display them in the sidebar with status indicators (running, success, failure). This requires adding a snippet to your shell's RC file.

Zsh

Add to ~/.zshrc:

# Claudette shell integration
if [[ -n "$CLAUDETTE_PTY" ]]; then
    _claudette_precmd() {
        local exit_code=$?
        printf '\033]133;D;%s\007' "$exit_code"
        printf '\033]133;A\007'
        return $exit_code
    }

    _claudette_preexec() {
        printf '\033]133;B\007'
        local cmd_encoded=$(printf '%s' "$1" | jq -sRr @uri 2>/dev/null || printf '%s' "$1" | od -An -tx1 | tr ' ' '%' | tr -d '\n')
        if [[ -n "$cmd_encoded" ]]; then
            printf '\033]133;E;%s\007' "$cmd_encoded"
        fi
        printf '\033]133;C\007'
    }

    autoload -Uz add-zsh-hook
    add-zsh-hook precmd _claudette_precmd
    add-zsh-hook preexec _claudette_preexec
fi

Bash

Add to ~/.bashrc:

# Claudette shell integration
if [[ -n "$CLAUDETTE_PTY" ]]; then
    _claudette_prompt_start() {
        printf '\033]133;A\007'
    }

    _claudette_prompt_cmd() {
        local exit_code=$?
        printf '\033]133;D;%s\007' "$exit_code"
        _claudette_prompt_start
        return $exit_code
    }

    _claudette_preexec() {
        printf '\033]133;B\007'
        local cmd_encoded=$(printf '%s' "$BASH_COMMAND" | jq -sRr @uri 2>/dev/null || echo "")
        if [[ -n "$cmd_encoded" ]]; then
            printf '\033]133;E;%s\007' "$cmd_encoded"
        fi
        printf '\033]133;C\007'
    }

    PROMPT_COMMAND="_claudette_prompt_cmd"
    trap '_claudette_preexec' DEBUG
fi

Fish

Add to ~/.config/fish/config.fish:

# Claudette shell integration
if test -n "$CLAUDETTE_PTY"
    function __claudette_prompt_start --on-event fish_prompt
        printf '\033]133;A\007'
    end

    function __claudette_preexec --on-event fish_preexec
        printf '\033]133;B\007'
        set cmd (string join ' ' $argv)
        set cmd_encoded (string escape --style=url -- $cmd)
        if test -n "$cmd_encoded"
            printf '\033]133;E;%s\007' "$cmd_encoded"
        end
        printf '\033]133;C\007'
    end

    function __claudette_postexec --on-event fish_postexec
        printf '\033]133;D;%s\007' $status
    end
end

After adding the snippet, restart your terminal or run source ~/.zshrc (or ~/.bashrc/~/.config/fish/config.fish). Commands will now appear in the sidebar.

Remote access

Claudette can connect to workspaces on another machine. The remote machine runs claudette-server, a headless backend that communicates over an encrypted WebSocket connection. The local Claudette app discovers or connects to it and displays remote repos, agents, and terminals alongside local ones.

Setting up the remote server

# Build and install the server binary
cargo install --path src-server

# Start it (generates a TLS certificate and pairing token on first run)
claudette-server

On startup the server prints a connection string:

claudette-server v0.1.0 listening on wss://0.0.0.0:7683
Name: Work Laptop

Connection string (paste into Claudette):
  claudette://work-laptop.local:7683/aBcDeFgH1234...

Connecting from the local app

Automatic (LAN): If both machines are on the same network, the server appears automatically in the sidebar under Nearby. Click Connect and enter the pairing token when prompted.

Manual: Click + Add remote in the sidebar footer and paste the full connection string. Claudette authenticates, stores a session token, and reconnects automatically on future launches.

Server management

# Regenerate the pairing token (revokes all existing sessions)
claudette-server regenerate-token

# Print the current connection string
claudette-server show-connection-string

# Bind to a specific interface or port
claudette-server --bind 192.168.1.50 --port 9000

# Disable mDNS advertisement
claudette-server --no-mdns

All traffic is encrypted with TLS. The local app pins the server's certificate fingerprint on first connection (trust-on-first-use), similar to SSH's known_hosts.

Community

Join us on Discord to ask questions, share feedback, and connect with other Claudette users.

Contributing

Contributions are welcome! Please read our Contributing Guide to get started. All participants are expected to follow our Code of Conduct.

Development notes

• The project uses Rust edition 2024 and Bun as the frontend package manager.
• The backend (src/) is a library crate consumed by the Tauri binary (src-tauri/).
• See CLAUDE.md for detailed architecture and contribution guidelines.
• See docs/tauri-migration-tdd.md for the technical design document.

License

This project is licensed under the MIT License.