gemini-cli-desktop

Automatically detects and routes all API communication through either Tauri IPC (desktop) or REST+WebSocket (web) based on a compile-time __WEB__ flag injected by Vite. The frontend uses a unified API client interface that abstracts the underlying transport mechanism, allowing a single React codebase to function as both a native desktop app and a web application without conditional logic scattered throughout components.

Implements a JSON-RPC 2.0 based protocol for structured, bidirectional communication with AI agents. The backend's ACP module marshals tool calls, streaming responses, and reasoning traces through a standardized message format that supports visual confirmation of tool executions, real-time response streaming, and structured error handling. This enables the frontend to display tool execution confirmations and reasoning chains as they happen.

Packages the application as a native desktop binary using Tauri, which embeds the React frontend and communicates with the Rust backend through Inter-Process Communication (IPC). Tauri provides a lightweight alternative to Electron, using the OS's native webview (WebKit on macOS, WebView2 on Windows) instead of bundling Chromium. The frontend invokes backend commands through Tauri's invoke API, which marshals function calls across the IPC boundary and returns results asynchronously.

Implements an event system where the backend emits events (session lifecycle, tool calls, responses, errors) that are propagated to the frontend through either IPC (desktop) or WebSocket (web). The EventEmitter trait is generic across the GeminiBackend, allowing different event implementations for different deployment modes. Events are emitted asynchronously and queued for delivery, ensuring the backend doesn't block on event handling. The frontend subscribes to event streams and updates UI state reactively.

Implements a REST API layer using the Rocket web framework that exposes backend functionality through HTTP endpoints. The API layer handles request parsing, validation, error handling, and response serialization. Each endpoint maps to a backend operation (create session, send message, list projects, etc.) and returns JSON responses. The API is used by the web frontend and can also be consumed by external clients. CORS and authentication middleware can be configured to control access.

Builds the frontend using React 18+ with a component-based architecture that separates concerns into layout components (sidebar, main content area), conversation interface components (message list, input), and utility components (search, project switcher). State management likely uses React Context or a state management library to maintain global state (current project, session, conversation history). Components are composed to build the full UI, with props flowing down and callbacks flowing up for user interactions.

Abstracts three primary backend types (Gemini CLI, Qwen Code, LLxprt Code) into a unified interface, with LLxprt Code acting as a universal adapter supporting 9+ providers (Anthropic, OpenAI, OpenRouter, Groq, Together, xAI, etc.). Each backend has distinct configuration schemas and authentication methods, but the frontend and core orchestration logic remain agnostic to the specific provider. The SessionManager in the backend handles provider-specific initialization and lifecycle.

Implements a full-text search system (crates/backend/src/search/mod.rs) that indexes all conversation messages, tool calls, and responses, enabling users to search across past interactions. The search module likely uses an inverted index or similar data structure to enable fast substring and phrase matching without scanning the entire conversation history on each query. Search results are ranked and returned to the frontend for display.

Implements a project management system (crates/backend/src/projects/mod.rs) that organizes conversations and file operations within discrete project contexts. Each project maintains its own conversation history, file system scope, and configuration. The backend enforces project boundaries for file operations, preventing accidental access to files outside the project directory. Projects can be created, switched, and deleted through the UI.

Streams AI responses token-by-token to the frontend in real-time, with special handling for code blocks that are parsed and rendered as diffs when they represent modifications to existing files. The backend detects code blocks in the response stream, extracts file paths and content, and the frontend uses a diff library to visualize changes side-by-side. This enables users to see code changes as the AI generates them, with visual confirmation of what will be modified.

Implements a SessionManager that creates isolated process contexts for each AI session, with environment variable guards (EnvVarGuard) that prevent credential leakage between sessions. Each session maintains its own process state, authentication context, and file system operations. Sessions can be created, paused, resumed, and terminated independently. The backend tracks session lifecycle events and emits them to the frontend for UI updates.

Implements internationalization (i18n) support across the React frontend, with translations for multiple languages managed through a structured i18n configuration. The frontend automatically detects user language preference and loads the appropriate translation bundle. The i18n system supports dynamic language switching without page reload, and all UI text (labels, buttons, messages, error strings) is externalized from components.

Implements a WebSocket system for the web deployment mode that enables real-time, bidirectional communication between the Rocket web server and frontend clients. The WebSocket connection streams AI responses, tool call notifications, session lifecycle events, and search results without polling. The backend maintains WebSocket connections per session and broadcasts events to connected clients. This provides the same real-time experience as the desktop IPC mode.

Implements a file system operations module (crates/backend/src/filesystem/mod.rs) that handles reading, writing, and listing files within project boundaries. The module enforces access control by validating all file paths against the project root directory, preventing directory traversal attacks or accidental access to files outside the project. File operations are exposed through the API layer and can be triggered by AI agents through tool calls or by users through the UI.