Alishahryar1/free-claude-code

Free Claude Code is a local proxy service that aggregates and routes requests to various AI model providers, supporting both Anthropic Messages and OpenAI Responses protocols. It provides a native desktop shell and a local Admin UI for managing provider configurations, model routing, and persistent code sessions. The system integrates with external coding agents like VS Code and JetBrains, as well as messaging platforms like Discord, while enforcing strict security and authentication controls for local-only access.

A new native application icon (app-icon.svg) has been added to the Free Claude Code assets, providing a distinct visual identity for the application.

_src/free\_claude\code/assets · high confidence

The assets folder now includes dark and light SVG wordmarks for "Free Claude Code" to support consistent branding in documentation and UI, alongside a new Mermaid source file and its rendered SVG diagram that visually explains the system architecture, including the proxy, model routing, and provider adapters.

assets · high confidence

The Admin UI now exposes a structured configuration interface with sections for providers, model routing, reasoning policies, runtime settings, messaging, voice, web tools, and diagnostics. Users can manage provider credentials, set default and tier-specific model overrides (Fable, Opus, Sonnet, Haiku), configure reasoning policies, and adjust runtime parameters like proxy authentication and timeouts. The system includes validation to ensure settings are valid before application, and displays provider configuration status to help users verify their setup.

_src/free\_claude\code/config/admin · high confidence

Added a new \src/free\_claude\_code/core/anthropic\ package providing shared protocol helpers for Anthropic-compatible interactions. This includes content block utilities, error mapping and serialization, portable image source normalization, request serialization and snapshotting, SSE stream aggregation for non-streaming responses, token estimation (including specific handling for tool-result images), and JSON schema helpers for tool arguments.

_src/free\_claude\code/core/anthropic · high confidence

Free Claude Code now includes a native desktop shell for Windows and macOS that runs in the system tray, manages the background server lifecycle (including graceful restarts and shutdown), and provides a menu to open the Admin dashboard, check status, restart the server, or quit. The shell uses a singleton lock to prevent multiple instances and keeps local traffic off outbound proxies. Additionally, a new \fcc-doctor\ command is available to generate and copy a JSON diagnostic report to the clipboard for bug reporting.

_src/free\_claude\code/cli · high confidence

The system now supports the OpenAI Responses protocol alongside the existing Anthropic Messages protocol. This change adds a new module that handles the translation of Anthropic Messages requests into OpenAI Responses format, manages the streaming of Responses events back to the client, and maps internal execution failures to OpenAI-compatible error envelopes. Users can now interact with providers that expose the OpenAI Responses interface, with the system handling the necessary request conversion, token usage tracking, and reasoning content preservation.

_src/free\_claude\_code/core/openai\responses · high confidence

Added a new streaming module under \src/free\_claude\_code/core/openai\_responses/streaming\ that implements the infrastructure for emitting OpenAI-style Responses events. This includes a \ResponseEventBuilder\ to format SSE events (such as \response.created\, \output\_item.added\, and text/function-call deltas), a \ResponsesOutputLedger\ to track active blocks and calculate token usage, and a \ResponseBlockCompleter\ to finalize text, reasoning, and tool blocks into the appropriate output items.

_src/free\_claude\_code/core/openai\responses/streaming · high confidence

This change introduces the core implementation files for the Anthropic streaming engine within the \src/free\_claude\_code/core/anthropic/streaming\ directory. It adds an SSE decoder (\decoder.py\) capable of handling arbitrarily split text chunks while preserving frame order, an emitter module (\emitter.py\) for serializing Anthropic-style Server-Sent Events and mapping stop reasons, and a ledger module (\ledger.py\) for tracking stream state. These components provide the foundational infrastructure for processing and emitting streaming responses in the Anthropic protocol format.

_src/free\_claude\code/core/anthropic/streaming · high confidence

Adds a new \smoke/lib\ package providing shared utilities for local-only smoke testing. This includes \child\_process.py\ to run subprocesses using the current interpreter (avoiding nested \uv run\ issues on Windows), \http.py\ for making HTTP requests and parsing SSE streams, \local\_providers.py\ to probe local provider availability, and \outcomes.py\/\skips.py\ to classify test outcomes and handle upstream-unavailable skips deterministically.

smoke/lib · high confidence

The runtime now provides a native OS folder picker dialog for Code sessions, replacing previous methods with platform-specific implementations (tkinter on Windows, osascript on macOS, zenity/kdialog on Linux) that run as isolated subprocesses. Additionally, the runtime includes a secure HTTP client for web search and fetch tools, featuring strict egress policies that validate DNS resolution to prevent server-side request forgery (SSRF) by pinning connections to pre-validated IP addresses and blocking private or localhost targets.

_src/free\_claude\code/runtime · high confidence

Free Claude Code now supports persistent, server-owned coding conversations that survive HTTP and browser lifetimes. This change introduces a new application module (\src/free\_claude\_code/application/code\_sessions\) containing the core service, models, and ports required to manage these sessions, including state management, storage integration, and event publishing.

_src/free\_claude\_code/application/code\sessions · high confidence

A new messaging subsystem has been added to provide a unified, platform-agnostic interface for interacting with Claude Code. This change introduces a structured event pipeline that parses raw CLI output into a transcript-friendly format, enabling real-time status updates and streaming responses in chat interfaces. The initial release includes a fully integrated Discord runtime, featuring inbound message handling, voice note transcription, and outbound delivery with rate limiting and message deduplication. Users can now manage conversations via slash commands like /stop, /clear, and /stats, which are handled through a dedicated dispatcher that supports both global and reply-scoped actions.

_src/free\_claude\code/messaging · high confidence

This change establishes the core configuration infrastructure for the Free Claude Code runtime. It introduces a centralized settings model with specific defaults (such as the NVIDIA Nemotron model and Anthropic token limits), a robust dotenv loader that supports both legacy paths and a new managed configuration directory (\~/.fcc), and a structured JSON logging system via Loguru that redacts sensitive credentials like API tokens and Bearer headers. Additionally, it defines filesystem paths for state, authentication, and locks, and provides utilities for generating browser-friendly local server URLs and validating provider proxy settings.

_src/free\_claude\code/config · high confidence

This change adds a comprehensive smoke testing infrastructure to validate product capabilities, including a capability contract map, feature inventory, and E2E drivers for CLI and provider matrices. It also introduces a local Admin UI with routes for configuration, provider status, and connected account management, serving versioned static assets.

free-claude-code · high confidence

This change establishes a new \src/free\_claude\_code/core\ package that centralizes shared application logic. It provides essential infrastructure including a sliding-window rate limiter, a process-wide token estimator using a bundled cl100k\_base tokenizer, and structured DEBUG tracing with automatic redaction of sensitive credentials. The core also handles platform-specific concerns such as Windows DPI awareness and cross-platform interprocess file locking, while exposing neutral utilities for model capability discovery, gateway model ID encoding, and OpenAI Chat Completions wire-history helpers.

_src/free\_claude\code/core · high confidence

Adds a new managed session layer in the CLI that pools and reuses persistent Claude Code subprocesses for messaging. This allows multiple conversations to be processed in parallel, with each new conversation getting its own session while replies to existing conversations reuse the same instance. The implementation includes a session manager for lifecycle control and a session class that handles subprocess execution, bounded stderr capture to prevent memory exhaustion, and proper cleanup on cancellation.

_src/free\_claude\code/cli/managed · high confidence

The application now includes a new \web\_tools\ module that handles the execution and policy enforcement for local web search and fetch capabilities. This service coordinates tool requests by validating inputs against egress policies (such as allowed URL schemes and private network access), managing token counting, and streaming responses via Server Tool SSE frames. It supports both explicit tool calls and automatic web search planning, allowing the system to intercept and process web-related model requests locally before or instead of sending them to upstream providers.

_src/free\_claude\_code/application/web\tools · high confidence

Free Claude Code now supports launching external coding agents (Aider, Cline CLI, Codex CLI, DeepSeek Harness, Grok Build, Hermes Agent, Muse Code, OpenCode, and Pi) directly from the terminal. These new launchers automatically configure the agents to route requests through the local FCC proxy, handling authentication, model catalog discovery, and environment isolation so users can use their preferred coding tools with FCC models without manual setup.

_src/free\_claude\code/cli/launchers · high confidence

This change introduces a new product-flow handler layer in the API package, exposing three distinct entry points: a MessagesHandler for standard chat interactions, a ResponsesHandler that implements the OpenAI Responses API protocol for streaming-compatible requests, and a TokenCountHandler for Anthropic-compatible token estimation. The ResponsesHandler specifically manages the lifecycle of OpenAI-style requests, including model routing, provider execution, and structured error handling for both streaming and pre-start failures, while the TokenCountHandler provides synchronous token counting with detailed request tracing.

_src/free\_claude\code/api/handlers · high confidence

The Admin interface has been replaced with a modern, dark-themed design that introduces a dedicated Code Sessions view for managing and monitoring active coding sessions, including context usage tracking and session controls. The Integrations tab now provides a streamlined way to connect Free Claude Code to external applications like VS Code, JetBrains ACP, and Claude Desktop, handling configuration and status updates directly from the UI. The interface also features a new searchable model combobox for easier model selection and improved form controls that disable browser auto-fill for sensitive fields.

_src/free\_claude\_code/api/admin\static · high confidence

The scripts directory now includes a comprehensive set of new tools to manage releases and local development workflows. A new version policy script (check\_version\_policy.py) enforces that release changes are tagged with patch, minor, or major prefixes and validates packaging requirements. A new publish\_release.py script automates the creation of GitHub releases and publishing to PyPI. Additionally, platform-specific CI scripts (ci.sh and ci.ps1) allow developers to run the same check sequence locally as GitHub Actions, including linting, type checking, and browser tests. The installation and uninstallation scripts have been expanded to support a wider range of coding agents (such as Muse, Hermes, and DeepSeek) and include native uninstallers for specific tools like Muse Code.

scripts · high confidence

The \providers\ package has removed the \BaseProvider\ abstract class, the \ProviderConfig\ data model, and the \NvidiaNimProvider\ implementation. This deletion eliminates the previous extensibility pattern for custom providers and removes the specific integration for NVIDIA NIM, indicating a shift in how provider interfaces and specific vendor integrations are managed in the codebase.

providers · high confidence

Deleted the \providers/utils\ package, including \\_\init\\_.py\, \heuristic\_tool\_parser.py\, \message\_converter.py\, \rate\_limiter.py\, and \sse\_builder.py\. This removes the local implementations for the sliding window rate limiter, the heuristic tool parser, the Anthropic-to-OpenAI message converter, and the SSE event builder, indicating these capabilities have been moved or replaced elsewhere in the codebase.

providers/utils · high confidence

The API layer now enforces strict local-only access for the Admin UI by validating the client host, Host header, and Origin header against loopback addresses, returning 403 for any remote access. Additionally, the Admin UI responses are explicitly marked with a 'no-store' Cache-Control header to prevent browser caching, and long-running client requests (such as /v1/messages and /v1/responses) are automatically cancelled if the HTTP client disconnects, ensuring resources are not wasted on abandoned operations.

_src/free\_claude\code/api · high confidence

The installer, uninstaller, and harness lifecycle tests in the \smoke/installers\ directory are now opt-in and no longer run in regular CI. To execute these checks, you must explicitly set the \FCC\_LIVE\_SMOKE=1\ environment variable and run \uv run pytest smoke/installers\. The suite includes new isolation fixtures for PowerShell module caches and a PTY runner to ensure process isolation, and it stubs external downloads to avoid modifying the user's environment.

smoke/installers · high confidence

The application layer now exposes a structured execution boundary via the new \ProviderExecutor\, which enforces a configurable \progress\_timeout\_seconds\ to cancel stalled provider streams and returns specific HTTP 503 errors when the service is still initializing. Additionally, the \reasoning.py\ module centralizes the resolution of client reasoning intents against FCC configuration, ensuring that thinking and output effort policies are applied consistently across both Messages and Responses API requests.

_src/free\_claude\code/application · high confidence

The provider subsystem has been restructured to use a centralized admission controller and execution lifecycle. This change introduces a new \ProviderExecution\ model that owns the attempt budget, retry logic, and state transitions for all provider calls, replacing previous ad-hoc handling. It also adds a new \CredentialValidation\ module that performs non-generating API key checks for a wide range of providers (including OpenRouter, Groq, DeepSeek, and others) during configuration application, ensuring keys are valid before inference begins. Additionally, new provider adapters for Cloudflare Workers AI and DeepSeek are added, along with a dedicated transport for native Anthropic Messages, establishing a more consistent and robust foundation for adding and managing external AI providers.

_src/free\_claude\code/providers · high confidence

The project license has been switched to the GNU Affero General Public License v3.0 (AGPL-3.0-only), requiring that source code be made available to users of networked deployments. This change accompanies the initial commit that established the repository's foundational structure, including the addition of a \CONTRIBUTING.md\ guide for developers, a \LICENSE\ file, and \.gitattributes\ for line-ending and linguist configuration. As part of this initial setup, legacy configuration files such as \.env.example\ and \nvidia\_nim\_models.json\ were removed, and the project now targets Python 3.14 with a \conftest.py\ registering shared pytest plugins.

(repo-wide) · high confidence

This change introduces a new \harnesses\ module that centralizes how Free Claude Code connects to and configures native client environments. It provides shared logic for setting up environment variables (such as proxy URLs and authentication tokens) while safely stripping conflicting keys, and implements platform-aware file writers for atomic configuration updates. Specifically, it adds integration support for Claude Desktop (managing its gateway configuration), VS Code (updating Claude Code settings and login state), native Codex (writing TOML provider configurations), and JetBrains ACP (configuring the Claude Agent adapter). This ensures that connected clients remain synchronized with the proxy and that local settings are preserved or updated consistently across different host applications.

_src/free\_claude\code/harnesses · high confidence

Add contract tests for provider catalog, admin manifest, and smoke infrastructure; Added API test suite for model fallback, admin configuration, and authentication; Added CLI launcher and session management tests; Added application-layer tests for code sessions, execution, and routing; Added comprehensive test coverage for messaging subsystem; Added core test coverage for async iterators, diagnostics, history replay, and protocol mappings; Added runtime tests for Codex integration, code sessions, and configuration management; Added test coverage for Anthropic protocol core components; Added test coverage for integration harnesses; Added test infrastructure and harness support for Code Sessions and provider integrations; Added tests for CI scripts, release automation, and version policy; Added tests for OpenAI Responses protocol translation and streaming; Added tests for managed configuration, provider catalog, and logging behavior; Expanded provider test coverage with new test infrastructure and provider-specific suites; Introduce local-only live smoke test suite; New end-to-end browser tests for the Admin UI and Code Sessions; New live smoke test suite for API, authentication, and provider prerequisites; New product-level end-to-end smoke test suite.

The project has been renamed to 'free-claude-code' and upgraded to require Python 3.14.7. Key dependency updates include FastAPI to \>=0.141.1, the OpenAI SDK to \>=3.18.0, httpx to \>=0.28.1, and pydantic to \>=2.13.5. New dependencies added include tiktoken for token counting, discord.py for Discord support, and various libraries for voice and desktop integration. The build system now uses hatchling with VCS-based versioning, and development tooling has been updated to include ruff, ty, and pytest-xdist.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 47 (-8.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 91 → 35 (-56.1)
• Architecture 94 → 88 (-6.5)
• Maturity 73 → 69 (-3.8)
• Readiness 32 → 43 (+10.5)
• Security 70 → 67 (-3.0)
• Accessibility 71 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (16 lines × 2) (tests/providers/test_streaming_errors.py)
• Duplicated block (5 lines × 2) (tests/messaging/test_messaging.py)
• High: security finding (details withheld)
• LLM evaluation failed
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No exposed public API
• No tests found
• Secret: square-access-token (uv.lock)
• Test reliability not included
• early-stage repository — too little history to judge knowledge freshness
• handleKeydown (cognitive 23) (src/free_claude_code/api/admin_static/admin.js)
• handleKeydown (cyclomatic 17) (src/free_claude_code/api/admin_static/admin.js)
• inputForField (cyclomatic 16) (src/free_claude_code/api/admin_static/admin.js)
• single-commit history — no usable git history window to measure hotspots
• single-maintainer — knowledge-concentration (bus factor) risk

• (anonymous) (cyclomatic 16) (src/free_claude_code/api/admin_static/session_ui.js)
• (anonymous)::activate (cognitive 17) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::bootstrap (cognitive 17) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::bootstrap (cyclomatic 16) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::buildPrompt (cognitive 75) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::buildPrompt (cyclomatic 25) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::deliver (cognitive 18) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::detail (cognitive 17) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::detail (cyclomatic 17) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::handleKeydown (cognitive 24) (src/free_claude_code/api/admin_static/model_combobox.js)
• (anonymous)::handleKeydown (cyclomatic 17) (src/free_claude_code/api/admin_static/model_combobox.js)
• (anonymous)::merge (cognitive 31) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::merge (cyclomatic 25) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::render (cognitive 47) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::render (cyclomatic 32) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::renderControls (cognitive 33) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::renderControls (cyclomatic 51) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::renderItem (cognitive 29) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::renderItem (cyclomatic 21) (src/free_claude_code/api/admin_static/code_sessions.js)
• (anonymous)::synchronize (cognitive 21) (src/free_claude_code/api/admin_static/code_sessions.js)
• …and 345 more

• 249 commits — 208 feature/other, 41 fixes

• (root) — 125 commits
• src/free_claude_code — 101 commits
• .github/workflows — 7 commits
• tests/providers — 6 commits
• tests/scripts — 3 commits
• tests/cli — 2 commits
• assets/admin-page.png — 1 commit
• scripts/publish_release.py — 1 commit
• smoke/installers — 1 commit
• smoke/lib — 1 commit
• tests/installers — 1 commit

• fix: Fix Admin restart recovery and graceful shutdown (#1669)
• fix: Fix Auto mode failures on providers that require thinking (#1703)
• fix: Fix Claude Code session forwarding to OpenCode (#1706)
• fix: Fix Codex App authentication for signed-in users (#1366)
• fix: Fix Codex auth configuration conflicts (#1369)
• fix: Fix Codex client tool discovery and sub-agent calls (#1765)
• fix: Fix Codex failing before its first reply on OpenCode Zen (#1696)
• fix: Fix Grok compatibility detection (#1597)
• fix: Fix Grok response timestamps and README provider count (#1672)
• fix: Fix Groq reasoning compatibility and rank it third (#1373)
• fix: Fix Hermes version parsing in the Windows installer (#1491)
• fix: Fix Muse model catalog visibility and metadata (#1674)
• fix: Fix OpenCode MissingSessionID errors through FCC (#1700)
• fix: Fix OpenCode session routing across FCC harnesses (#1708)
• fix: Fix Pi thinking effort translation for GitHub Copilot (#1676)
• fix: Fix README license badge link (#1888)
• fix: Fix Windows Muse installation with empty PATH entries (#1729)
• fix: Fix blurry Windows folder picker and tray menu (#1714)
• fix: Fix cache usage accounting across protocol boundaries (#1372)
• fix: Fix custom tool IDs when switching Codex providers (#1831)
• …and 229 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• free-claude-code

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Alishahryar1/free-claude-code was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.