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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.2.67
+Version: 6.2.68
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.2.67 → free_claude_code-6.2.68}/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.68}/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