free-claude-code 6.3.0__tar.gz → 6.3.1__tar.gz

{free_claude_code-6.3.0 → free_claude_code-6.3.1}/.github/workflows/validate-bug-report-version.yml

@@ -37,6 +37,8 @@ jobs:
               if (doctor.length) {
                 if (doctor.length !== 1) return { valid: false };
                 let text = doctor[0].replace(/^FCC doctor output\r?\n/, "").trim();
+                const details = text.match(/^<details>\s*<summary>[^<>\r\n]*<\/summary>\s*([\s\S]*?)\s*<\/details>$/);
+                if (details) text = details[1].trim();
                 const fence = text.match(/^```(?:json)?\r?\n([\s\S]*)\r?\n```$/);
                 if (fence) text = fence[1];
                 let report;
@@ -58,7 +60,25 @@ jobs:
               const reportedVersion = versionMatches.length === 1 ? versionMatches[0][1] : undefined;
               return { valid: reportedVersion !== undefined || fieldValue === "None", reportedVersion };
             };
-            const { reportedVersion, valid } = parseReport(issue.body || "");
+            const collapseDoctorReport = (body) => {
+              const sections = body.split(/(?=^### )/m);
+              const index = sections.findIndex((section) => /^### FCC doctor output\r?\n/.test(section));
+              if (index === -1 || !parseReport(body).valid) return body;
+              const section = sections[index];
+              const text = section.replace(/^### FCC doctor output\r?\n/, "").trim();
+              if (text.startsWith("<details>")) return body;
+              const newline = section.includes("\r\n") ? "\r\n" : "\n";
+              const content = text.startsWith("```") ? text : `\`\`\`json${newline}${text}${newline}\`\`\``;
+              const wrapped = ["<details>", "<summary>FCC doctor output</summary>", "", content, "", "</details>"].join(newline);
+              const start = section.indexOf(text);
+              sections[index] = section.slice(0, start) + wrapped + section.slice(start + text.length);
+              return sections.join("");
+            };
+            const formattedBody = collapseDoctorReport(issue.body || "");
+            if (formattedBody !== (issue.body || "")) {
+              await github.rest.issues.update({ ...repo, issue_number, body: formattedBody });
+            }
+            const { reportedVersion, valid } = parseReport(formattedBody);
             const labelName = "needs-fcc-version";
             const invalidMarker = "<!-- fcc-version-validator -->";
             const outdatedMarker = "<!-- fcc-version-outdated -->";

{free_claude_code-6.3.0 → free_claude_code-6.3.1}/PKG-INFO

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

{free_claude_code-6.3.0 → free_claude_code-6.3.1}/src/free_claude_code/cli/launchers/cline.py

@@ -1,4 +1,10 @@
-"""Installed Cline launcher with private native provider settings."""
+"""Installed Cline launcher with private native provider settings.
+
+Sessions run with an isolated Hub discovery path so a stale or user-run Cline
+Hub can never capture an fcc-cline session: the child resolves Hub state only
+inside FCC's ephemeral configuration directory, which is deleted on exit. A
+Hub started with ordinary cline keeps using its own discovery file.
+"""
 
 import re
 from collections.abc import Sequence
@@ -29,6 +35,17 @@ def _configure(
     )
     providers_path = files.write_json("settings/providers.json", config.providers)
     files.write_json("settings/models.json", config.models)
+    # Interactive Cline passes backendMode:"auto" to core, which overrides
+    # CLINE_SESSION_BACKEND_MODE and may attach to (or start) a detached Hub
+    # that resolves provider settings from the user's global store instead of
+    # FCC's ephemeral files. Redirecting Hub discovery into the ephemeral tree
+    # makes that attachment impossible without touching user-run Hub state.
+    # (Verified: shipped Cline 3.0.57 honors CLINE_HUB_DISCOVERY_PATH as the
+    # discovery-path override in its hub resolver.)
+    hub_discovery_path = files.directory / "hub" / "production.json"
+    # Pre-create the directory, not the file: the child records Hub discovery
+    # state here on startup, and the Hub itself must own the file.
+    hub_discovery_path.parent.mkdir(parents=True, mode=0o700, exist_ok=True)
     return PreparedLaunch(
         [ctx.binary_path, "--provider", CLINE_PROVIDER_ID, *args],
         client_environment(
@@ -37,6 +54,7 @@ def _configure(
             updates={
                 "CLINE_PROVIDER_SETTINGS_PATH": str(providers_path),
                 "CLINE_SESSION_BACKEND_MODE": "local",
+                "CLINE_HUB_DISCOVERY_PATH": str(hub_discovery_path),
             },
         ),
     )

{free_claude_code-6.3.0 → free_claude_code-6.3.1}/tests/cli/test_cline_launcher.py

@@ -139,6 +139,7 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
     from tests.cli.test_launcher_workflow import launch
 
     launch_ids = []
+    hub_paths = []
 
     def inspect(command, env):
         providers_path = Path(env["CLINE_PROVIDER_SETTINGS_PATH"])
@@ -152,6 +153,16 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
         assert settings["model"] in models["providers"][CLINE_PROVIDER_ID]["models"]
         assert env["CLINE_SESSION_BACKEND_MODE"] == "local"
         assert command[:3] == ["cline", "--provider", "openai-native"]
+        hub_path = Path(env["CLINE_HUB_DISCOVERY_PATH"])
+        assert hub_path.parent.name == "hub"
+        assert hub_path.name == "production.json"
+        # Hub discovery must resolve inside the same ephemeral tree as the
+        # private provider files. The hub/ directory is pre-created so the
+        # child can record discovery state; the file itself must not exist.
+        assert hub_path.parent.parent == providers_path.parent.parent
+        assert hub_path.parent.is_dir()
+        assert not hub_path.exists()
+        hub_paths.append(hub_path)
 
     launch_capture.on_start = inspect
     args = ["--model", "native-selection", "--data-dir", "native-data-dir"]
@@ -159,3 +170,32 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
     assert launch_capture.commands[0][-len(args) :] == args
     launch("cline", [])
     assert launch_ids[0] != launch_ids[1]
+    assert hub_paths[0] != hub_paths[1]
+    assert all(not hub_path.exists() for hub_path in hub_paths)
+
+
+def test_cline_hub_discovery_path_overrides_stale_inherited_value(
+    launch_capture, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from tests.cli.test_launcher_workflow import launch
+
+    monkeypatch.setenv("CLINE_HUB_DISCOVERY_PATH", "stale-user-hub-discovery.json")
+    dir_existed_at_start = []
+
+    def inspect(command, env):
+        hub_dir = Path(env["CLINE_HUB_DISCOVERY_PATH"]).parent
+        dir_existed_at_start.append(hub_dir.is_dir())
+
+    launch_capture.on_start = inspect
+    launch("cline", [])
+    hub_path = Path(launch_capture.environments[0]["CLINE_HUB_DISCOVERY_PATH"])
+    # The stale user-level discovery file must be replaced by the isolated
+    # ephemeral path, never inherited by the fcc-cline child. The hub/
+    # directory is pre-created at launch (checked via on_start, since the
+    # ephemeral tree is cleaned up when the launcher exits); only the file
+    # itself must not be pre-created.
+    assert hub_path.name == "production.json"
+    assert hub_path.parent.name == "hub"
+    assert str(hub_path) != "stale-user-hub-discovery.json"
+    assert dir_existed_at_start == [True]
+    assert not hub_path.exists()

{free_claude_code-6.3.0 → free_claude_code-6.3.1}/tests/contracts/test_issue_form_version_validation.py

@@ -76,6 +76,21 @@ def test_bug_forms_require_description_and_post_install_diagnostics() -> None:
     "body, valid, version",
     [
         ('### FCC doctor output\n\n```json\n{"version":"1.2.3"}\n```', True, "1.2.3"),
+        (
+            '### FCC doctor output\n\n<details>\n<summary>FCC doctor output</summary>\n\n```json\n{"version":"1.2.3"}\n```\n\n</details>',
+            True,
+            "1.2.3",
+        ),
+        (
+            '### FCC doctor output\r\n\r\n<details>\r\n<summary>Diagnostics</summary>\r\n\r\n```json\r\n{"version":"1.2.3"}\r\n```\r\n\r\n</details>',
+            True,
+            "1.2.3",
+        ),
+        (
+            "### FCC doctor output\n\n<details>\n<summary>Diagnostics</summary>\n\n```json\n{invalid}\n```\n\n</details>",
+            False,
+            None,
+        ),
         (
             '### FCC doctor output\r\n\r\n```json\r\n{"version":"1.2.3"}\r\n```',
             True,
@@ -101,6 +116,12 @@ def test_bug_forms_require_description_and_post_install_diagnostics() -> None:
     ],
 )
 def test_report_parser_uses_the_correct_form_section(body, valid, version):
+    result = _parse_report(body)
+    assert result["valid"] is valid
+    assert result.get("reportedVersion") == version
+
+
+def _parse_report(body):
     patterns = "\n".join(
         f"const {name} = {json.dumps(_workflow_pattern(name))};"
         for name in ("fieldPattern", "versionPattern")
@@ -109,9 +130,71 @@ def test_report_parser_uses_the_correct_form_section(body, valid, version):
     script += (
         f"\nprocess.stdout.write(JSON.stringify(parseReport({json.dumps(body)})));"
     )
-    result = _run_javascript(script)
-    assert result["valid"] is valid
-    assert result.get("reportedVersion") == version
+    return _run_javascript(script)
+
+
+def test_plain_doctor_report_can_be_collapsed_without_changing_its_data(
+    monkeypatch, capsys
+):
+    from free_claude_code.cli import doctor
+
+    copied = []
+    report = {"version": "1.2.3", "model_routing": {"model": "provider/```</details>"}}
+    monkeypatch.setattr(doctor, "collect_report", lambda: report)
+    monkeypatch.setattr(doctor, "copy_text", copied.append)
+    doctor.main([])
+    assert json.loads(capsys.readouterr().out) == report
+    assert json.loads(copied[0]) == report
+    body = "### FCC doctor output\n\n" + copied[0]
+    collapsed = _collapse_report(body)
+    assert collapsed.startswith("### FCC doctor output\n\n<details>\n")
+    assert json.loads(collapsed.split("```json\n", 1)[1].rsplit("```", 1)[0]) == report
+    assert _parse_report(collapsed) == {"valid": True, "reportedVersion": "1.2.3"}
+
+
+def _collapse_report(body):
+    patterns = "\n".join(
+        f"const {name} = {json.dumps(_workflow_pattern(name))};"
+        for name in ("fieldPattern", "versionPattern")
+    )
+    script = (
+        patterns
+        + "\n"
+        + _javascript_function("parseReport")
+        + "\n"
+        + _javascript_function("collapseDoctorReport")
+    )
+    script += f"\nprocess.stdout.write(JSON.stringify(collapseDoctorReport({json.dumps(body)})));"
+    return _run_javascript(script)
+
+
+@pytest.mark.parametrize("newline", ["\n", "\r\n"])
+@pytest.mark.parametrize("fenced", [False, True])
+def test_collapsing_only_changes_doctor_section_and_is_idempotent(newline, fenced):
+    report = '{"version":"1.2.3","model":"$&```</details>"}'
+    content = f"```json\n{report}\n```" if fenced else report
+    before = "### Describe the issue\n\nMy description and ![image](https://example.com/image.png)\n\n### FCC doctor output\n\n"
+    after = "\n\n### Other details\n\nKeep this text exactly.\n"
+    body = (before + content + after).replace("\n", newline)
+    collapsed = _collapse_report(body)
+    assert collapsed.startswith(before.replace("\n", newline) + "<details>")
+    assert collapsed.endswith(after.replace("\n", newline))
+    assert report in collapsed
+    assert _collapse_report(collapsed) == collapsed
+    assert _parse_report(collapsed) == {"valid": True, "reportedVersion": "1.2.3"}
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "### Installation issue\n\nCannot install",
+        "### FCC version\n\n1.2.3",
+        "### FCC doctor output\n\n{invalid}",
+        '### FCC doctor output\n\n{"version":"1.2.3"}\n\n### FCC doctor output\n\n{"version":"1.2.3"}',
+    ],
+)
+def test_collapsing_leaves_other_or_invalid_reports_untouched(body):
+    assert _collapse_report(body) == body
 
 
 @pytest.mark.parametrize(
@@ -248,6 +331,11 @@ const github = {
         record("getIssue", args);
         return { data: liveIssue };
       },
+      update: async (args) => {
+        record("updateIssue", args);
+        liveIssue.body = args.body;
+        return { data: liveIssue };
+      },
       getLabel: async (args) => record("getLabel", args),
       createLabel: async (args) => record("createLabel", args),
       addLabels: async (args) => {
@@ -336,6 +424,7 @@ process.stdout.write(JSON.stringify({ calls, comments }));
     assert names.count("deleteComment") == 3
     assert names.count("getLatestRelease") == 4
     assert names.count("getIssue") == 6
+    assert names.count("updateIssue") == (3 if form == "doctor" else 0)
     assert names.count("getLabel") == 1
     assert names.count("addLabels") == 1
     assert names.count("removeLabel") == 2
@@ -354,7 +443,11 @@ process.stdout.write(JSON.stringify({ calls, comments }));
     )
     assert result["comments"] == []
     assert "cancel-in-progress: false" in workflow
-    assert "github.rest.issues.update({" not in workflow
+    assert all(
+        set(call["args"]) == {"owner", "repo", "issue_number", "body"}
+        for call in calls
+        if call["name"] == "updateIssue"
+    )
     assert 'state: "closed"' not in workflow