free-claude-code 6.2.67__tar.gz → 6.2.69__tar.gz

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/.github/dependabot.yml

@@ -2,6 +2,7 @@ version: 2
 updates:
   - package-ecosystem: "uv"
     directory: "/"
+    versioning-strategy: increase
     schedule:
       interval: "weekly"
     groups:

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/.github/workflows/tests.yml

@@ -142,7 +142,7 @@ jobs:
       - name: Run Playwright
         run: >-
           uv run --locked pytest e2e -v --tb=short
-          -o faulthandler_timeout=10 --durations=20
+          -o thread_dump_timeout=10 --durations=20
           --tracing=retain-on-failure --screenshot=only-on-failure
           --full-page-screenshot --output=test-results
 

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.2.67
+Version: 6.2.69
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -9,10 +9,10 @@ Requires-Dist: aiohttp>=3.14.3
 Requires-Dist: anyio>=4.15.1
 Requires-Dist: discord-py>=2.7.1
 Requires-Dist: fastapi[standard]>=0.141.1
-Requires-Dist: github-copilot-sdk==1.0.13
+Requires-Dist: github-copilot-sdk==1.0.14
 Requires-Dist: google-auth[requests]>=2.56.3
 Requires-Dist: grpcio-tools>=1.81.1
-Requires-Dist: grpcio>=1.83.1
+Requires-Dist: grpcio>=1.84.0
 Requires-Dist: httpx2[socks]<3,>=2.7.0
 Requires-Dist: httpx[socks]>=0.28.1
 Requires-Dist: json5>=0.15.0
@@ -20,7 +20,7 @@ Requires-Dist: jsonschema>=4.25.0
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: markdown-it-py>=4.2.0
 Requires-Dist: nvidia-riva-client>=2.26.0
-Requires-Dist: openai>=3.14.0
+Requires-Dist: openai>=3.18.0
 Requires-Dist: pillow>=12.0.0; sys_platform == 'win32' or sys_platform == 'darwin'
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: pystray>=0.19.5; sys_platform == 'win32' or sys_platform == 'darwin'
@@ -30,7 +30,7 @@ Requires-Dist: requests[socks]>=2.34.2
 Requires-Dist: simplejson>=4.1.2
 Requires-Dist: tiktoken>=0.13.0
 Requires-Dist: tomlkit>=0.13.3
-Requires-Dist: uvicorn>=0.52.1
+Requires-Dist: uvicorn>=0.53.0
 Provides-Extra: voice-local
 Requires-Dist: accelerate>=1.15.0; extra == 'voice-local'
 Requires-Dist: librosa>=1.0.0; extra == 'voice-local'

free_claude_code-6.2.69/conftest.py

@@ -0,0 +1,3 @@
+"""Shared pytest plugin registration."""
+
+pytest_plugins = ["e2e.thread_diagnostics"]

free_claude_code-6.2.69/e2e/thread_diagnostics.py

@@ -0,0 +1,66 @@
+"""Slow-test stack snapshots without the native faulthandler watchdog."""
+
+import os
+import sys
+import threading
+import traceback
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import TextIO
+
+import pytest
+
+_output = pytest.StashKey[TextIO]()
+
+
+@contextmanager
+def dump_threads_after(
+    timeout: float, output: TextIO, test_name: str
+) -> Iterator[None]:
+    def dump() -> None:
+        print(f"Test still running after {timeout:g}s: {test_name}", file=output)
+        for thread_id, frame in sys._current_frames().items():
+            print(f"\nThread {thread_id}:", file=output)
+            traceback.print_stack(frame, file=output)
+        output.flush()
+
+    timer = threading.Timer(timeout, dump)
+    timer.name = "fcc-test-diagnostics"
+    timer.daemon = True
+    timer.start()
+    try:
+        yield
+    finally:
+        timer.cancel()
+        timer.join()
+
+
+def pytest_addoption(parser) -> None:
+    parser.addini("thread_dump_timeout", "Print slow-test thread stacks", default="0")
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    if float(config.getini("thread_dump_timeout")) > 0:
+        # Windows xdist workers preserve stderr here and redirect descriptor 2 to NUL.
+        # Keep a stable output descriptor across pytest's per-test capture changes.
+        config.stash[_output] = os.fdopen(
+            os.dup(sys.stderr.fileno()),
+            "w",
+            encoding="utf-8",
+            errors="backslashreplace",
+        )
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    if _output in config.stash:
+        config.stash[_output].close()
+        del config.stash[_output]
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_protocol(item: pytest.Item):
+    timeout = float(item.config.getini("thread_dump_timeout"))
+    if timeout <= 0:
+        return (yield)
+    with dump_threads_after(timeout, item.config.stash[_output], item.nodeid):
+        return (yield)

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/pyproject.toml

@@ -13,7 +13,7 @@ requires-python = ">=3.14.0"
 dependencies = [
     "anyio>=4.15.1",
     "fastapi[standard]>=0.141.1",
-    "uvicorn>=0.52.1",
+    "uvicorn>=0.53.0",
     "httpx[socks]>=0.28.1",
     "httpx2[socks]>=2.7.0,<3",
     "markdown-it-py>=4.2.0",
@@ -22,7 +22,7 @@ dependencies = [
     "tiktoken>=0.13.0",
     "python-telegram-bot>=22.8",
     "discord.py>=2.7.1",
-    "openai>=3.14.0",
+    "openai>=3.18.0",
     "loguru>=0.7.0",
     "aiohttp>=3.14.3",
     "jsonschema>=4.25.0",
@@ -32,9 +32,9 @@ dependencies = [
     "requests[socks]>=2.34.2",
     "pystray>=0.19.5; sys_platform == 'win32' or sys_platform == 'darwin'",
     "Pillow>=12.0.0; sys_platform == 'win32' or sys_platform == 'darwin'",
-    "github-copilot-sdk==1.0.13",
+    "github-copilot-sdk==1.0.14",
     "simplejson>=4.1.2",
-    "grpcio>=1.83.1",
+    "grpcio>=1.84.0",
     "grpcio-tools>=1.81.1",
     "nvidia-riva-client>=2.26.0",
 ]
@@ -87,12 +87,12 @@ explicit = true
 
 [dependency-groups]
 dev = [
-    "packaging>=26.0",
+    "packaging>=26.3",
     "pytest>=9.1.1",
     "pytest-asyncio>=1.4.0",
     "pytest-cov>=7.1.0",
-    "ty>=0.0.80",
-    "ruff>=0.16.7",
+    "ty>=0.0.83",
+    "ruff>=0.16.8",
     "pytest-xdist>=3.8.0",
     "pytest-playwright>=0.9.0",
     "pyyaml>=6.0.3",

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/scripts/publish_release.py

@@ -40,6 +40,11 @@ class Publisher:
     def gh(self, *args: str) -> str:
         return command(["gh", "release", *args, "--repo", self.repository])
 
+    def release_api(self, suffix: str, *args: str) -> dict:
+        return json.loads(
+            command(["gh", "api", f"repos/{self.repository}/releases{suffix}", *args])
+        )
+
     def releases(self) -> dict:
         pages = json.loads(
             command(
@@ -112,16 +117,23 @@ class Publisher:
             command(["git", "tag", tag, target])
             command(["git", "push", "origin", f"refs/tags/{tag}"])
         if release is None:
-            self.gh(
-                "create",
-                tag,
-                "--draft",
-                "--verify-tag",
-                "--title",
-                tag,
-                "--generate-notes",
-                "--notes-start-tag",
-                previous,
+            notes = self.release_api(
+                "/generate-notes",
+                "-f",
+                f"tag_name={tag}",
+                "-f",
+                f"previous_tag_name={previous}",
+            )
+            release = self.release_api(
+                "",
+                "-f",
+                f"tag_name={tag}",
+                "-f",
+                f"name={tag}",
+                "-f",
+                f"body={notes['body']}",
+                "-F",
+                "draft=true",
             )
         print(f"Publishing {tag} from {target}")
         with tempfile.TemporaryDirectory(prefix="fcc-release-") as temporary:
@@ -132,7 +144,7 @@ class Publisher:
             try:
                 if command(["git", "status", "--porcelain"], cwd=source).strip():
                     raise ValueError("Release source must be clean")
-                self.stage(tag, version, source, dist)
+                self.stage(tag, release["id"], version, source, dist)
                 command(
                     [
                         "uv",
@@ -154,9 +166,11 @@ class Publisher:
             cwd=source,
         )
 
-    def stage(self, tag: str, version: str, source: Path, dist: Path) -> None:
+    def stage(
+        self, tag: str, release_id: int, version: str, source: Path, dist: Path
+    ) -> None:
         names = set(distribution_names(version))
-        assets = self.releases()[tag]["assets"]
+        assets = self.release_api(f"/{release_id}")["assets"]
         if any(asset["name"] not in names for asset in assets):
             raise ValueError(f"Unexpected assets on {tag}")
         complete = (
@@ -173,7 +187,7 @@ class Publisher:
             command(["uv", "build", "--no-sources", "--out-dir", str(dist)], cwd=source)
             self.validate(source, dist, version)
             self.gh("upload", tag, *(str(dist / name) for name in sorted(names)))
-            assets = self.releases()[tag]["assets"]
+            assets = self.release_api(f"/{release_id}")["assets"]
         if {asset["name"] for asset in assets} != names or len(assets) != 2:
             raise ValueError(f"Incomplete staged distributions for {tag}")
         for asset in assets:

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/tests/runtime/test_codex_catalog.py

@@ -13,6 +13,7 @@ from free_claude_code.application.ports import (
 )
 from free_claude_code.cli.launchers.catalog_http import catalog_models_from_response
 from free_claude_code.config.settings import Settings
+from free_claude_code.core.json_types import JsonObject
 from free_claude_code.core.model_capabilities import ModelInputModality
 from free_claude_code.harnesses.codex_model_catalog import build_codex_model_catalog
 from free_claude_code.runtime.codex_app_server import CodexHarnessFactory
@@ -42,6 +43,9 @@ class FakeRequestRuntime(RequestRuntimePort):
     async def wait_for_catalog(self) -> ModelCatalogSnapshot:
         return ModelCatalogSnapshot(self._settings, self._cached_infos)
 
+    def catalog_status(self) -> JsonObject:
+        raise AssertionError("Catalog publication must not query startup status.")
+
     def current_settings(self) -> Settings:
         return self._settings
 

{free_claude_code-6.2.67 → free_claude_code-6.2.69}/tests/scripts/test_publish_release.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import json
+from itertools import pairwise
 from pathlib import Path
 from typing import TypedDict
 
@@ -40,6 +41,7 @@ class Asset(TypedDict):
 
 
 class Release(TypedDict):
+    id: int
     tag_name: str
     draft: bool
     prerelease: bool
@@ -51,6 +53,7 @@ class FakeRemote:
         self.repo = repo
         self.releases: dict[str, Release] = {
             "v1.2.3": {
+                "id": 1,
                 "tag_name": "v1.2.3",
                 "draft": False,
                 "prerelease": False,
@@ -73,16 +76,34 @@ class FakeRemote:
                 return ""
             return git(Path(cwd or self.repo), *args[1:])
         if args[:2] == ["gh", "api"]:
-            return json.dumps([list(self.releases.values())])
-        if args[:3] == ["gh", "release", "create"]:
-            tag = args[3]
-            self.releases[tag] = {
-                "tag_name": tag,
-                "draft": True,
-                "prerelease": False,
-                "assets": [],
-            }
-        elif args[:3] == ["gh", "release", "upload"]:
+            endpoint = next(arg for arg in args if arg.startswith("repos/"))
+            fields = dict(
+                field.split("=", 1)
+                for flag, field in pairwise(args)
+                if flag in {"-f", "-F"}
+            )
+            if endpoint.endswith("?per_page=100"):
+                return json.dumps([list(self.releases.values())])
+            if endpoint.endswith("/generate-notes"):
+                assert fields["previous_tag_name"] in self.releases
+                return json.dumps({"body": "Generated release notes"})
+            if endpoint.endswith("/releases"):
+                assert fields["draft"] == "true"
+                assert fields["body"] == "Generated release notes"
+                tag = fields["tag_name"]
+                self.releases[tag] = {
+                    "id": len(self.releases) + 1,
+                    "tag_name": tag,
+                    "draft": True,
+                    "prerelease": False,
+                    "assets": [],
+                }
+                return json.dumps(self.releases[tag])
+            release_id = int(endpoint.rsplit("/", 1)[1])
+            return json.dumps(
+                next(r for r in self.releases.values() if r["id"] == release_id)
+            )
+        if args[:3] == ["gh", "release", "upload"]:
             tag = args[3]
             for filename in args[4:]:
                 file = Path(filename)
@@ -155,6 +176,31 @@ def test_nonrelease_never_allocates_or_builds(releases):
     assert not any(c[:2] == ["git", "push"] for c in remote.calls)
 
 
+@pytest.mark.parametrize("existing_draft", [False, True])
+def test_stale_release_list_does_not_block_staging(
+    releases, monkeypatch, existing_draft
+):
+    _, remote = releases
+    head = remote.advance()
+    if existing_draft:
+        remote.fail = "stage"
+        with pytest.raises(RuntimeError, match="interrupted staging"):
+            remote.publisher().publish(head)
+    listed = json.dumps([list(remote.releases.values())])
+
+    def stale_listing(args, *, cwd=None):
+        if args[:2] == ["gh", "api"] and any(
+            arg.endswith("/releases?per_page=100") for arg in args
+        ):
+            return listed
+        return remote.command(args, cwd=cwd)
+
+    monkeypatch.setattr(publishing, "command", stale_listing)
+    remote.publisher().publish(head)
+    assert not remote.releases["v1.2.4"]["draft"]
+    assert set(remote.uploaded) == set(publishing.distribution_names("1.2.4"))
+
+
 @pytest.mark.parametrize("failure", ["stage", "publish", "finalize"])
 def test_retries_keep_version_and_published_bytes(releases, failure):
     repo, remote = releases

free_claude_code-6.2.69/tests/test_thread_diagnostics.py

@@ -0,0 +1,83 @@
+import io
+import os
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+import pytest
+
+from e2e.thread_diagnostics import dump_threads_after
+
+
+@pytest.mark.parametrize("workers", ["0", "2"])
+def test_diagnostic_reaches_stderr_with_pytest_capture(tmp_path, workers):
+    plugin = Path(__file__).resolve().parents[1] / "e2e/thread_diagnostics.py"
+    (tmp_path / "thread_diagnostics.py").write_text(
+        plugin.read_text(encoding="utf-8"), encoding="utf-8"
+    )
+    (tmp_path / "pytest.ini").write_text("[pytest]\n", encoding="utf-8")
+    (tmp_path / "test_slow.py").write_text(
+        "import time\ndef test_slow():\n    time.sleep(0.2)\n", encoding="utf-8"
+    )
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "pytest",
+            "-p",
+            "xdist.plugin",
+            "-p",
+            "thread_diagnostics",
+            "-n",
+            workers,
+            "-o",
+            "thread_dump_timeout=0.03",
+        ],
+        cwd=tmp_path,
+        env={
+            **os.environ,
+            "PYTEST_ADDOPTS": "",
+            "PYTEST_PLUGINS": "",
+            "PYTEST_DISABLE_PLUGIN_AUTOLOAD": "1",
+        },
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert "test_slow.py::test_slow" in result.stderr
+    assert "Thread " in result.stderr
+
+
+class DiagnosticOutput(io.StringIO):
+    def __init__(self):
+        super().__init__()
+        self.flushed = threading.Event()
+
+    def flush(self):
+        self.flushed.set()
+
+
+def test_slow_test_reports_stacks_without_interrupting_execution():
+    output = DiagnosticOutput()
+    with dump_threads_after(0.001, output, "slow-test"):
+        assert output.flushed.wait(5)
+        assert "slow-test" in output.getvalue()
+        assert "test_slow_test_reports_stacks_without_interrupting_execution" in (
+            output.getvalue()
+        )
+    assert not any(t.name == "fcc-test-diagnostics" for t in threading.enumerate())
+
+
+@pytest.mark.parametrize("fails", [False, True])
+def test_completion_cancels_and_joins_pending_diagnostic(fails):
+    output = DiagnosticOutput()
+    try:
+        with dump_threads_after(60, output, "completed-test"):
+            if fails:
+                raise RuntimeError("original failure")
+    except RuntimeError as error:
+        assert fails and str(error) == "original failure"
+    assert output.getvalue() == ""
+    assert not any(t.name == "fcc-test-diagnostics" for t in threading.enumerate())