claude-code-generator 0.6.1__tar.gz → 0.6.2__tar.gz

{claude_code_generator-0.6.1/src/claude_code_generator.egg-info → claude_code_generator-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.6.1
+Version: 0.6.2
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.6.1 → claude_code_generator-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.6.1"
+version = "0.6.2"
 description = "Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file."
 readme = "README.md"
 license = { text = "MIT" }

{claude_code_generator-0.6.1 → claude_code_generator-0.6.2/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.6.1
+Version: 0.6.2
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.6.1 → claude_code_generator-0.6.2}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -212,6 +212,7 @@ tests/test_phase6.py
 tests/test_phase65_budget.py
 tests/test_phase6_5_integration.py
 tests/test_phase6_5_integration_cycle2.py
+tests/test_phase6_5_port_isolation.py
 tests/test_phase6_5_prompt.py
 tests/test_phase6_5_prompt_snapshot.py
 tests/test_phase6_5_run.py

{claude_code_generator-0.6.1 → claude_code_generator-0.6.2}/src/code_generator/__init__.py

@@ -1,3 +1,3 @@
 """code-generator: orchestrator CLI for end-to-end project generation."""
 
-__version__ = "0.6.1"
+__version__ = "0.6.2"

{claude_code_generator-0.6.1 → claude_code_generator-0.6.2}/src/code_generator/orchestrator/phase6_5_verify.py

@@ -32,7 +32,7 @@ import socket
 import subprocess
 import sys
 import time
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any
 
 import httpx
@@ -348,6 +348,48 @@ def _spawn_child(entry_cmd: list[str], cwd: Path, env: Mapping[str, str]) -> sub
     )
 
 
+def _alloc_free_port() -> int:
+    """Bind ``127.0.0.1:0`` to obtain an OS-assigned free TCP port, then
+    release it.
+
+    Phase 6.5 must not hardcode ``:8000`` — co-resident tooling (e.g. the
+    claude-mem plugin's ``chroma run``) squats well-known ports and returns
+    404 to every health probe, burning the entire repair-retry budget on a
+    purely environmental collision. An ephemeral port makes that collision
+    structurally impossible.
+
+    There is a benign TOCTOU window between release here and the app binding
+    the port; :func:`_ensure_verify_port` closes it by re-checking (and
+    rerolling) immediately before each attempt.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _ensure_verify_port(port: int, *, logger: logging.Logger) -> int:
+    """Pre-flight port guard (#2).
+
+    If *port* was claimed by a foreign listener between attempts (a plugin
+    rebinding, a leaked uvicorn from a prior run), reroll to a fresh free
+    port instead of letting the squatter fail a tier and consume a retry.
+    A genuine app bug still fails the tier on its own port; only
+    environmental collisions are absorbed here.
+    """
+    if not _port_open(port):
+        return port
+    new_port = _alloc_free_port()
+    logger.warning(
+        "Phase 6.5 verify port %d occupied by a foreign listener before the "
+        "attempt began; rerolled to %d so the retry budget is not spent on "
+        "an environmental port collision.",
+        port,
+        new_port,
+    )
+    return new_port
+
+
 def _port_open(port: int, host: str = "127.0.0.1", timeout_s: float = 0.25) -> bool:
     try:
         with socket.create_connection((host, port), timeout=timeout_s):
@@ -654,6 +696,10 @@ async def run(
     budget = Phase65BudgetTracker(wall_budget_s=wall_budget_s, turn_budget=turn_budget)
     budget.start()
 
+    # Ephemeral verification port (#1): allocate once so base_url stays
+    # stable across the retry loop; re-checked per attempt by the guard (#2).
+    verify_port = _alloc_free_port()
+
     for attempt in range(max_retries):
         budget.check(turns_consumed=attempt, logger=logger)
         progress = _begin_attempt(target, progress, attempt)
@@ -661,6 +707,7 @@ async def run(
         if attempt > 0:
             _soft_reset_for_repair(project_dir, attempt + 1)
 
+        verify_port = _ensure_verify_port(verify_port, logger=logger)
         outcome = _run_tiers(
             project_dir,
             state,
@@ -669,6 +716,7 @@ async def run(
             progress,
             attempt,
             target,
+            port=verify_port,
             logger=logger,
             detector=detector,
         )
@@ -722,6 +770,7 @@ def _run_tiers(
     attempt: int,
     target: Any,
     *,
+    port: int,
     logger: logging.Logger,
     detector: DeviationDetector | None = None,
 ) -> TierResult | None:
@@ -731,13 +780,27 @@ def _run_tiers(
     :func:`tier_selector.select_tiers` then iterates ``spec.tiers``,
     skipping any tier with ``enabled=False`` and recording the
     skip reason on ``Phase65Progress``.
+
+    *port* is the ephemeral free port allocated by :func:`run` (#1). It is
+    woven into ``base_url``, the subprocess env (``PORT`` / ``UVICORN_PORT``
+    / ``APP_PORT``), and the persisted spec so both the programmatic tier
+    runners and the SDK repair agent bind the same collision-free port.
     """
-    env = build_agent_env()
+    base_url = f"http://127.0.0.1:{port}"
+    # The SDK repair agent does not inherit this env (its credentials are
+    # locked at shared-client open time); it learns the port from the
+    # persisted spec's base_url/T1.port instead. These vars steer the
+    # programmatic T0/T2 subprocesses and any app that honours $PORT.
+    env = {
+        **build_agent_env(),
+        "PORT": str(port),
+        "UVICORN_PORT": str(port),
+        "APP_PORT": str(port),
+    }
     requirements_path = project_dir / ".code-generator" / "requirements.md"
     endpoints = _load_endpoints(requirements_path)
-    base_url = "http://127.0.0.1:8000"
 
-    spec = _persist_spec_for_attempt(project_dir, requirements_path)
+    spec = _persist_spec_for_attempt(project_dir, requirements_path, port)
     _record_skips(target, progress, spec, attempt, logger=logger)
     save_state(state_path, state)
 
@@ -759,11 +822,15 @@ def _run_tiers(
     return None
 
 
-def _persist_spec_for_attempt(project_dir: Path, requirements_path: Path) -> AgentSpec:
+def _persist_spec_for_attempt(project_dir: Path, requirements_path: Path, port: int) -> AgentSpec:
     """Build the ``AgentSpec`` for this run and atomically persist it.
 
     The spec is the single source of truth consumed by :func:`_run_tiers`
-    and any later replay tooling.
+    *and* the SDK repair agent (the prompt instructs it to trust the spec's
+    declared ports). ``build_agent_spec`` stays pure and deterministic
+    (default ``:8000``); the ephemeral *port* (#1) is layered on here via
+    :func:`dataclasses.replace` so the agent boots the app on a
+    collision-free port instead of the well-known ``:8000``.
     """
     tiers = select_tiers(project_dir, requirements_path)
     requirements_text = (
@@ -771,6 +838,13 @@ def _persist_spec_for_attempt(project_dir: Path, requirements_path: Path) -> Age
     )
     flags = {tier.tier_id: tier.enabled for tier in tiers if tier.tier_id in {"T3", "T4"}}
     spec = build_agent_spec(project_dir, requirements_text, flags)
+    spec = replace(
+        spec,
+        base_url=f"http://127.0.0.1:{port}",
+        tiers=tuple(
+            replace(tier, port=port) if tier.port is not None else tier for tier in spec.tiers
+        ),
+    )
     persist_agent_spec(spec, project_dir / ".code-generator")
     return spec
 

claude_code_generator-0.6.2/tests/test_phase6_5_port_isolation.py

@@ -0,0 +1,87 @@
+"""Phase 6.5 ephemeral-port isolation (#1) and pre-flight port guard (#2).
+
+Regression cover for the well-known-port collision that exhausted the
+repair-retry budget: a co-resident ``chroma run`` (claude-mem plugin)
+squatting ``:8000`` returned 404 to every health probe, so attempts 1+2
+failed environmentally and attempt 3's real fix landed after the budget
+was already spent. The fix moves verification onto an OS-assigned free
+port and rerolls if that port is squatted before an attempt starts.
+"""
+
+from __future__ import annotations
+
+import logging
+import socket
+from pathlib import Path
+
+from code_generator.orchestrator.agent_spec import load_agent_spec
+from code_generator.orchestrator.phase6_5_verify import (
+    _alloc_free_port,
+    _ensure_verify_port,
+    _persist_spec_for_attempt,
+)
+
+_LOGGER = logging.getLogger("test.phase6_5.port_isolation")
+
+
+def _make_project(tmp_path: Path) -> Path:
+    project_dir = tmp_path / "project"
+    (project_dir / ".code-generator").mkdir(parents=True)
+    (project_dir / ".code-generator" / "requirements.md").write_text(
+        "# Demo\n\n## Tech Stack\n\nFastAPI\n", encoding="utf-8"
+    )
+    return project_dir
+
+
+def test_alloc_free_port_returns_a_bindable_ephemeral_port() -> None:
+    port = _alloc_free_port()
+    assert 1024 < port < 65536
+    # Released back to the OS — re-bindable, proving it was genuinely free.
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(("127.0.0.1", port))
+
+
+def test_persisted_spec_carries_ephemeral_port_not_8000(tmp_path: Path) -> None:
+    project_dir = _make_project(tmp_path)
+    port = _alloc_free_port()
+
+    _persist_spec_for_attempt(
+        project_dir, project_dir / ".code-generator" / "requirements.md", port
+    )
+
+    spec = load_agent_spec(project_dir / ".code-generator")
+    assert spec.base_url == f"http://127.0.0.1:{port}"
+    assert spec.base_url != "http://127.0.0.1:8000"
+    # Every tier that declares a port (T1) is rewritten to the free port —
+    # this is the field the SDK repair agent reads to boot the app.
+    ported = [t for t in spec.tiers if t.port is not None]
+    assert ported, "expected at least one tier with an explicit port (T1)"
+    assert all(t.port == port for t in ported)
+
+
+def test_guard_passes_through_a_free_port() -> None:
+    port = _alloc_free_port()
+    assert _ensure_verify_port(port, logger=_LOGGER) == port
+
+
+def test_guard_rerolls_when_port_is_squatted(caplog) -> None:
+    """A foreign listener on the chosen port → reroll, never reuse it.
+
+    This is the chroma-on-:8000 scenario in miniature: the guard must
+    hand back a *different*, free port so the squatter cannot fail a
+    tier and burn a retry.
+    """
+    squatter = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    squatter.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    squatter.bind(("127.0.0.1", 0))
+    squatter.listen(1)
+    squatted_port = squatter.getsockname()[1]
+    try:
+        with caplog.at_level(logging.WARNING):
+            rerolled = _ensure_verify_port(squatted_port, logger=_LOGGER)
+        assert rerolled != squatted_port
+        assert 1024 < rerolled < 65536
+        assert "rerolled" in caplog.text
+    finally:
+        squatter.close()