{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-piebald-ai-gemini-cli-desktop","slug":"mcp-piebald-ai-gemini-cli-desktop","name":"gemini-cli-desktop","type":"cli","url":"https://github.com/Piebald-AI/gemini-cli-desktop","page_url":"https://unfragile.ai/mcp-piebald-ai-gemini-cli-desktop","categories":["code-editors"],"tags":["agent-client-protocol","agentic","cross-platform","desktop","desktop-app","development","gemini","gemini-api","gemini-cli","gemini-cli-ui","gemini-cli-web","gemini-desktop","gemini-ui","multilingual","qwen","qwen-code","qwen3-coder","tauri","web","webapp"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_0","uri":"capability://tool.use.integration.dual.deployment.abstraction.with.runtime.mode.detection","name":"dual-deployment abstraction with runtime mode detection","description":"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.","intents":["Deploy the same UI codebase as both a native desktop application and a web server without maintaining separate frontends","Switch between local desktop and remote web deployment without rebuilding the frontend","Reduce frontend complexity by centralizing transport abstraction in a single API layer"],"best_for":["teams building cross-platform AI tools that need both native and web deployments","developers wanting to avoid frontend duplication across desktop and web targets"],"limitations":["Compile-time flag means deployment mode is baked in at build time; cannot switch modes at runtime","Adds abstraction layer that must be maintained when adding new API endpoints","WebSocket fallback for web mode requires additional server-side WebSocket infrastructure"],"requires":["Vite as build tool with custom config to inject __WEB__ flag","Tauri 1.0+ for desktop mode","Rocket web server for web mode","React 18+ for frontend"],"input_types":["API requests (JSON)"],"output_types":["API responses (JSON), WebSocket events (JSON)"],"categories":["tool-use-integration","architecture-pattern"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_1","uri":"capability://tool.use.integration.agent.communication.protocol.acp.json.rpc.2.0.orchestration","name":"agent communication protocol (acp) json-rpc 2.0 orchestration","description":"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.","intents":["Send structured tool calls to AI agents and receive confirmations before execution","Stream AI reasoning and responses in real-time to the UI with proper message sequencing","Handle tool execution results and feed them back to the AI agent in a standardized format","Display tool call history and reasoning traces with full fidelity"],"best_for":["developers building agentic AI interfaces that need tool call visibility","teams integrating multiple AI providers with a unified protocol","applications requiring real-time streaming of AI reasoning"],"limitations":["JSON-RPC 2.0 overhead adds ~50-100ms per round-trip compared to raw streaming","Requires backend implementation of ACP protocol for each new AI provider","Tool call confirmation flow is synchronous, blocking agent execution until UI acknowledgment"],"requires":["Rust backend with ACP module implementation (crates/backend/src/acp/mod.rs)","Frontend WebSocket or IPC connection capable of bidirectional messaging","AI provider SDK that supports tool/function calling"],"input_types":["JSON-RPC 2.0 requests with tool definitions","Tool execution results (JSON)"],"output_types":["JSON-RPC 2.0 responses with streaming chunks","Tool call notifications","Reasoning traces (JSON)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_10","uri":"capability://tool.use.integration.tauri.based.native.desktop.application.with.ipc.communication","name":"tauri-based native desktop application with ipc communication","description":"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.","intents":["Distribute the application as a native desktop app without Electron's overhead","Provide fast, low-latency communication between frontend and backend","Access OS-level features (file dialogs, system tray, notifications) through Tauri APIs","Create a self-contained binary that doesn't require a separate web server"],"best_for":["developers building cross-platform desktop apps who want smaller bundle sizes than Electron","teams prioritizing performance and memory efficiency","applications needing tight integration with OS-level features"],"limitations":["Tauri is less mature than Electron; fewer third-party integrations available","WebView2 on Windows requires a separate installation; not all Windows versions are supported","IPC marshalling adds ~5-10ms latency per command compared to in-process function calls","Debugging IPC issues is more complex than debugging in-process code","Tauri's security model is stricter; some operations require explicit allowlisting"],"requires":["Tauri 1.0+ framework","Rust toolchain for building the backend","Node.js and npm for building the frontend","OS-specific requirements: Xcode on macOS, Visual Studio Build Tools on Windows, GTK on Linux"],"input_types":["Frontend commands (function names and arguments)","User interactions (clicks, input)"],"output_types":["Command results (JSON)","Events from backend (lifecycle, errors)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_11","uri":"capability://automation.workflow.event.driven.architecture.with.async.event.emission","name":"event-driven architecture with async event emission","description":"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.","intents":["Decouple backend operations from UI updates through event-driven architecture","Stream multiple concurrent events (responses, tool calls, errors) without blocking","Maintain UI state synchronization with backend state through events","Enable real-time notifications of backend state changes"],"best_for":["applications with complex, concurrent operations that need UI synchronization","teams wanting to decouple backend logic from frontend presentation","systems requiring real-time event streaming"],"limitations":["Event ordering must be carefully managed; out-of-order events can cause UI inconsistencies","Event queue can grow unbounded if frontend doesn't consume events fast enough","Debugging event flows is complex; requires tracing through multiple layers","Event schema changes require coordination between backend and frontend"],"requires":["Rust backend with EventEmitter trait implementation","Async runtime (likely Tokio) for event handling","Frontend event subscription mechanism"],"input_types":["Backend operations that trigger events","Event metadata (timestamp, source, type)"],"output_types":["Event stream (JSON events)","Event notifications to frontend"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_12","uri":"capability://tool.use.integration.rest.api.layer.with.rocket.web.framework","name":"rest api layer with rocket web framework","description":"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.","intents":["Expose backend functionality through standard HTTP endpoints","Enable external clients to integrate with the application","Provide a documented API surface for the web deployment","Handle request validation and error responses consistently"],"best_for":["teams building web-based deployments of the application","developers wanting to integrate the tool with external systems","applications needing a documented, standard API interface"],"limitations":["REST API adds latency compared to direct function calls; each request has HTTP overhead","Request/response serialization adds CPU overhead for large payloads","Stateless HTTP requests don't map well to stateful operations like streaming; requires WebSocket for real-time updates","API versioning and backward compatibility must be managed explicitly"],"requires":["Rocket web framework 0.5+","Rust backend with API endpoint implementations","HTTP client library on the frontend"],"input_types":["HTTP requests (GET, POST, PUT, DELETE) with JSON bodies","URL parameters and query strings"],"output_types":["JSON responses with status codes","Error responses with error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_13","uri":"capability://text.generation.language.react.based.ui.with.state.management.and.component.composition","name":"react-based ui with state management and component composition","description":"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.","intents":["Build a responsive, interactive UI for the AI assistant","Manage complex UI state (current project, session, conversation history) consistently","Compose reusable components to reduce code duplication","Provide a smooth user experience with real-time updates"],"best_for":["teams building modern web/desktop UIs with React","developers wanting a component-based architecture","applications requiring complex state management"],"limitations":["React adds ~100-200KB to bundle size (minified)","State management complexity increases with application size; large apps need careful architecture","Re-renders can cause performance issues if not optimized with useMemo/useCallback","Learning curve for developers unfamiliar with React and component composition"],"requires":["React 18+","Node.js and npm for building","State management library (Context API, Redux, Zustand, etc.)","CSS framework or styling solution"],"input_types":["User interactions (clicks, input, keyboard)","Backend events (responses, tool calls, errors)"],"output_types":["Rendered HTML/CSS UI","User commands sent to backend"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_2","uri":"capability://tool.use.integration.multi.backend.provider.abstraction.with.9.ai.service.support","name":"multi-backend provider abstraction with 9+ ai service support","description":"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.","intents":["Switch between different AI providers without changing the UI or conversation history","Support users with different API keys or provider preferences in a single application","Add new AI providers by implementing a new backend adapter without touching frontend code","Manage provider-specific authentication (OAuth, API keys, environment variables) transparently"],"best_for":["teams building AI tools that want provider flexibility","users who want to compare outputs across multiple AI models","developers integrating with multiple AI ecosystems (Google, Alibaba, OpenAI, Anthropic, etc.)"],"limitations":["Each provider has different model capabilities, token limits, and cost structures — abstraction doesn't normalize these differences","Provider-specific features (e.g., Google's Gemini reasoning tokens) may not be exposed through the unified interface","Authentication complexity increases with each new provider; requires secure credential storage","LLxprt Code adapter adds latency (~100-200ms) compared to direct provider SDKs"],"requires":["Rust backend with provider-specific SDK integrations","API keys or credentials for each enabled provider","Environment variable configuration or secure credential storage","Provider SDKs: google-generativeai, openrouter-rs, anthropic-rs, etc."],"input_types":["Provider configuration (JSON with auth details)","Chat messages (text, code, images)","Tool definitions (JSON schema)"],"output_types":["Streamed text responses","Tool calls (JSON)","Usage statistics (tokens, cost)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_3","uri":"capability://search.retrieval.full.text.search.across.conversation.history.with.indexing","name":"full-text search across conversation history with indexing","description":"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.","intents":["Find previous conversations or code snippets without scrolling through history","Locate when a specific tool was called or a particular error occurred","Search across multiple projects or sessions to find related discussions","Export or reference past AI responses by searching for keywords"],"best_for":["developers with large conversation histories who need to find past interactions","teams using the tool for research and need to track AI outputs over time","users managing multiple projects and needing cross-project search"],"limitations":["Search index must be rebuilt or incrementally updated as new conversations are added","Full-text search performance degrades with very large conversation histories (100k+ messages)","No support for semantic search (meaning-based) — only lexical/substring matching","Search index is stored locally; not synchronized across devices in web mode"],"requires":["Rust backend with search module implementation","Persistent storage for conversation history (SQLite or similar)","Frontend search UI component"],"input_types":["Search query (text string)","Optional filters (date range, project, backend type)"],"output_types":["Ranked list of matching messages with context","Highlighted search terms in results"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_4","uri":"capability://automation.workflow.project.scoped.conversation.and.file.management","name":"project-scoped conversation and file management","description":"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.","intents":["Organize conversations by project or codebase to keep work separated","Scope file operations to a specific project directory to prevent accidental modifications","Switch between multiple projects without losing conversation history","Export or archive project conversations and associated files"],"best_for":["developers working on multiple codebases simultaneously","teams using the tool for different client projects or features","users wanting to keep conversations organized by context"],"limitations":["Project switching requires reloading conversation history from storage","File operations are scoped to project root; cannot easily reference files outside the project","No built-in project sharing or collaboration features","Project metadata (name, path, settings) is stored locally; not synced across devices"],"requires":["Rust backend with project management module","Persistent storage for project metadata and conversation history","Frontend UI for project creation, switching, and deletion"],"input_types":["Project configuration (name, root directory path)","File paths relative to project root","Conversation messages within project context"],"output_types":["Project list with metadata","Conversation history for selected project","File tree for project directory"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_5","uri":"capability://code.generation.editing.real.time.streaming.response.with.code.diff.visualization","name":"real-time streaming response with code diff visualization","description":"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.","intents":["See AI-generated code changes in real-time as they're being produced","Visualize diffs of proposed file modifications before applying them","Understand what code the AI is generating by seeing before/after comparisons","Apply or reject code changes with visual confirmation"],"best_for":["developers using AI for code generation and wanting to see changes before applying","teams reviewing AI-generated code changes","users who want to understand exactly what the AI is modifying"],"limitations":["Diff visualization requires parsing code blocks from streaming response; malformed code blocks may not render correctly","Large diffs (1000+ lines) can cause UI performance issues","Streaming adds latency compared to waiting for complete response before rendering","Diff visualization only works for text files; binary files not supported"],"requires":["Streaming response support from AI provider","Frontend diff library (e.g., react-diff-viewer or similar)","Code block parsing logic in backend or frontend"],"input_types":["Streamed text response with code blocks","File path and content from code blocks"],"output_types":["Streamed text rendered in real-time","Parsed code blocks with diffs","Side-by-side diff visualization"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_6","uri":"capability://automation.workflow.session.based.process.lifecycle.management.with.environment.isolation","name":"session-based process lifecycle management with environment isolation","description":"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.","intents":["Isolate credentials and environment variables between different AI sessions","Manage multiple concurrent AI conversations without interference","Pause and resume sessions without losing state","Track session lifecycle events (creation, termination, errors) for debugging"],"best_for":["applications handling sensitive credentials that must be isolated per session","teams running multiple concurrent AI interactions","developers needing to debug session lifecycle issues"],"limitations":["Session isolation adds memory overhead; many concurrent sessions consume significant RAM","Pausing sessions requires serializing state; large conversation histories slow down pause/resume","Environment variable guards prevent accidental leakage but add ~10-20ms per session operation","No built-in session persistence across application restarts"],"requires":["Rust backend with SessionManager and EnvVarGuard implementation","Event emitter system for lifecycle notifications","Persistent storage for session state (optional)"],"input_types":["Session configuration (backend type, credentials)","Session commands (create, pause, resume, terminate)"],"output_types":["Session ID and metadata","Lifecycle events (created, paused, resumed, terminated)","Session state snapshots"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_7","uri":"capability://text.generation.language.multilingual.ui.with.i18n.framework","name":"multilingual ui with i18n framework","description":"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.","intents":["Support users in their native language without building separate UIs","Switch languages dynamically without restarting the application","Manage translations centrally and add new languages without code changes","Ensure all error messages and help text are localized"],"best_for":["teams building AI tools for global audiences","developers wanting to support multiple languages from day one","applications targeting non-English speaking users"],"limitations":["i18n adds ~50-100KB to bundle size depending on number of languages","Translation maintenance requires external translators or translation services","Right-to-left (RTL) languages require additional CSS and layout adjustments","Dynamic language switching may cause brief UI flicker while translations load"],"requires":["i18n library (likely i18next or similar) configured in React","Translation files for each supported language (JSON or YAML format)","Frontend language detection and switching logic"],"input_types":["Language preference (from browser or user settings)","Translation keys (strings like 'button.submit')"],"output_types":["Localized UI text in user's language","Language switcher component"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_8","uri":"capability://tool.use.integration.websocket.based.real.time.event.streaming.for.web.deployment","name":"websocket-based real-time event streaming for web deployment","description":"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.","intents":["Stream AI responses and tool calls in real-time to web clients","Receive UI events (tool confirmations, user inputs) from clients in real-time","Maintain persistent connection for long-running AI operations","Support multiple concurrent clients connected to the same session"],"best_for":["teams deploying the application as a web service","users accessing the tool from browsers without native app installation","applications needing real-time collaboration or multi-client support"],"limitations":["WebSocket connections consume server resources; many concurrent clients can exhaust memory","Network latency adds 50-200ms compared to local IPC in desktop mode","WebSocket connections are not persistent across server restarts; clients must reconnect","Firewall/proxy configurations may block WebSocket connections","No built-in authentication/authorization for WebSocket connections"],"requires":["Rocket web server with WebSocket support","Frontend WebSocket client library","Network connectivity and WebSocket-compatible firewall rules"],"input_types":["WebSocket messages (JSON) from client","Backend events (responses, tool calls, lifecycle events)"],"output_types":["Streamed responses and events to connected clients","Acknowledgments and status updates"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-piebald-ai-gemini-cli-desktop__cap_9","uri":"capability://automation.workflow.file.system.operations.with.project.scoped.access.control","name":"file system operations with project-scoped access control","description":"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.","intents":["Read files from the project directory for AI analysis","Write or modify files based on AI suggestions","List directory contents for file browsing","Prevent accidental or malicious access to files outside the project"],"best_for":["developers using AI to analyze or modify their codebase","teams wanting safe file operations without manual path validation","applications where AI agents need controlled file system access"],"limitations":["Access control is enforced at the project root level; cannot grant fine-grained permissions to specific files","Large file operations (reading/writing 100MB+ files) may cause UI freezing","No built-in file locking; concurrent writes to the same file may cause conflicts","Symbolic links and hard links may bypass access control if not handled carefully"],"requires":["Rust backend with file system module","Project root directory configured and accessible","File system permissions on the host OS"],"input_types":["File path (relative to project root)","File content (for write operations)","Directory path (for listing operations)"],"output_types":["File content (text or binary)","Directory listing (file names, sizes, modification times)","Operation status (success/error)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":41,"verified":false,"data_access_risk":"high","permissions":["Vite as build tool with custom config to inject __WEB__ flag","Tauri 1.0+ for desktop mode","Rocket web server for web mode","React 18+ for frontend","Rust backend with ACP module implementation (crates/backend/src/acp/mod.rs)","Frontend WebSocket or IPC connection capable of bidirectional messaging","AI provider SDK that supports tool/function calling","Tauri 1.0+ framework","Rust toolchain for building the backend","Node.js and npm for building the frontend"],"failure_modes":["Compile-time flag means deployment mode is baked in at build time; cannot switch modes at runtime","Adds abstraction layer that must be maintained when adding new API endpoints","WebSocket fallback for web mode requires additional server-side WebSocket infrastructure","JSON-RPC 2.0 overhead adds ~50-100ms per round-trip compared to raw streaming","Requires backend implementation of ACP protocol for each new AI provider","Tool call confirmation flow is synchronous, blocking agent execution until UI acknowledgment","Tauri is less mature than Electron; fewer third-party integrations available","WebView2 on Windows requires a separate installation; not all Windows versions are supported","IPC marshalling adds ~5-10ms latency per command compared to in-process function calls","Debugging IPC issues is more complex than debugging in-process code","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3393650436778028,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.065Z","last_scraped_at":"2026-05-03T14:23:44.761Z","last_commit":"2026-03-08T15:18:16Z"},"community":{"stars":425,"forks":49,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-piebald-ai-gemini-cli-desktop","compare_url":"https://unfragile.ai/compare?artifact=mcp-piebald-ai-gemini-cli-desktop"}},"signature":"VZQcCS6dz/DRS1NUAAtCcthEzsUXoFDlqHp5M+pVjDsbtTWjL09/riEXFT6inmwUgx0EFAGP29K2T3umGnruDA==","signedAt":"2026-06-21T00:07:01.569Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-piebald-ai-gemini-cli-desktop","artifact":"https://unfragile.ai/mcp-piebald-ai-gemini-cli-desktop","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-piebald-ai-gemini-cli-desktop","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}