copper-pilot-cli 0.1.11__tar.gz → 1.0.0__tar.gz

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/HISTORY.md

@@ -5,6 +5,104 @@ Changelog
 (unreleased)
 ------------
 
+Fix
+~~~
+- Do not count echoed request fields toward the stream byte budget.
+  [AdityaNG, Claude Opus 5.5]
+
+  The hosted service echoes the request `query` (and, in the final frame,
+  `context`) in every chat_response. A live probe showed the echo is ~97% of
+  each frame. A validate arch.review prompt is ~76 KB, so a long review on a
+  large board crossed the 64 MiB client budget after ~815 frames (2601 s)
+  although the hosted output itself was ~4.4 MB, and the check ERRORed with
+  "Chat exceeded the client stream byte budget."
+
+  The budget now counts frame bytes minus the echoed request fields the
+  client never reads, and the error names the counted size and frame count.
+- Stop cutting long hosted answers at the 16 KB status limit. [AdityaNG,
+  Claude Opus 5.5]
+
+  Every hosted response frame went through sanitize_status, which caps
+  status lines at 16 KB. The hosted side can send a whole answer as one
+  response frame, so a validate review longer than 16 KB lost the end of
+  its findings JSON. The reviewer then found no json block, sent a repair
+  turn into the already huge thread, and the server refused it ("This
+  conversation is too large to continue"), so arch.review ERRORed. Chat
+  and ACP answers over 16 KB were cut the same way.
+
+  Response text now gets a 1 MiB bound; status and reasoning lines keep
+  16 KB. A validate check that fails with a hosted failed final also
+  records the hosted turn id, as chat does.
+- Surface stalled or failed hosted turns instead of hanging. [AdityaNG,
+  Claude Opus 5.5]
+
+  Three ways a long ACP turn could hang or hide its cause:
+
+  - idle_frame_timeout was None, so a hosted server that kept the socket
+    (and keepalive) up but stopped sending hung the prompt forever. It now
+    defaults to 10 minutes (COPPER_PILOT_IDLE_TIMEOUT_SECONDS, 0 disables)
+    and raises the existing retryable CHAT_IDLE_TIMEOUT with the silence
+    length in the message. The hosted side heartbeats every 25 s.
+  - A failed hosted final (success false) still waited, unbounded, for
+    background shells and then ran a continuation turn. A runaway background
+    command held the hosted error back until the caller timed out, and a
+    continuation that succeeded still reported the stale error. A failed
+    final now ends the turn and kills leftover background processes.
+  - The hosted copy "CopperPilot ran into an error." carries no detail. The
+    ACP error now names the hosted turn id, and the client logs the failing
+    final frame's keys, so the server-side cause can be found.
+- Guard the state lock with sys.platform so ty passes on Windows.
+  [AdityaNG, Claude Opus 5.5]
+- Stop concurrent sessions racing on recent-projects state. [AdityaNG,
+  Claude Opus 5.5]
+
+  Every process wrote recent-projects.json (and config.json) through the
+  same fixed temp name, so parallel `copper-pilot acp` session starts moved
+  or clobbered each other's temp file and session/new failed with
+  FileNotFoundError on os.replace.
+
+  Writes now go through a per-write mkstemp temp file, the recent-projects
+  read-modify-write holds a POSIX flock so no entry is dropped, and the
+  bookkeeping logs instead of raising so it can never fail a session.
+
+Other
+~~~~~
+- Merge pull request #37 from CopperPilot/fix/stream-byte-budget.
+  [Aditya]
+
+  fix: do not count echoed request fields toward the stream byte budget
+- Merge pull request #35 from CopperPilot/fix/long-response-truncation.
+  [Aditya]
+
+  fix: stop cutting long hosted answers at the 16 KB status limit
+- Merge pull request #33 from CopperPilot/fix/hosted-stream-stall.
+  [Aditya]
+
+  fix: surface stalled or failed hosted turns instead of hanging
+- Merge pull request #34 from CopperPilot/fix/validate-hierarchical-
+  nets. [Aditya]
+
+  fix(validate): ground findings that cite label names of hierarchical nets
+- Fix(validate): ground findings that cite label names of hierarchical
+  nets. [AdityaNG, Claude Opus 5.5]
+
+  KiCad names local and hierarchical label nets with their sheet path
+  ("/RAIL_IO_3", "/power/RAIL_IO_3"), but reviewers cite the label
+  ("RAIL_IO_3"). Grounding compared the cited name to the full net name
+  only, so every real finding on such a board was marked UNGROUNDED and
+  could never fail a blocking check (WARN / exit 3 instead of FAIL).
+
+  A cited net now grounds when it equals a design net name or is a
+  "/"-boundary suffix of one; invented names still do not.
+- Merge pull request #32 from CopperPilot/fix/recent-projects-race.
+  [Aditya]
+
+  fix: stop concurrent ACP sessions racing on recent-projects state
+
+
+0.1.11 (2026-10-25)
+-------------------
+
 Fix
 ~~~
 - Do not block turn cancellation on loading-widget removal. [Cursor,
@@ -40,6 +138,7 @@ Fix
 
 Other
 ~~~~~
+- Release: version 0.1.11 🚀 [AdityaNG]
 - Merge pull request #31 from naveen-
   forkd/feat/cli_chat_chrome_2026_10_24. [Aditya]
 

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: copper-pilot-cli
-Version: 0.1.11
+Version: 1.0.0
 Summary: CopperPilot hosted agent for the terminal and LangChain
 Project-URL: Homepage, https://copperpilot.ai
 Project-URL: Repository, https://github.com/CopperPilot/copper-pilot-cli

copper_pilot_cli-1.0.0/VERSION

@@ -0,0 +1 @@
+1.0.0

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_acp.py

@@ -1252,7 +1252,11 @@ class CopperAcpAgent:
             await send(session_id=session_id, update=update_agent_thought_text(f"{label}\n"))
         elif kind == EventKind.FINAL.value and isinstance(payload, dict):
             if payload.get("success") is False or payload.get("error"):
-                return str(payload.get("error") or "hosted failure")
+                message = str(payload.get("error") or "hosted failure")
+                # The hosted copy is generic; the turn id lets the service
+                # owners find the server-side cause.
+                turn_id = event.get("turn_id")
+                return f"{message} (hosted turn {turn_id})" if turn_id else message
         return None
 
     # -------------------------------------------------------- broker handlers

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_config.py

@@ -2,7 +2,11 @@
 
 from __future__ import annotations
 
+import contextlib
 import os
+import sys
+import tempfile
+from collections.abc import Generator
 from dataclasses import dataclass
 from pathlib import Path
 from urllib.parse import urlparse
@@ -60,3 +64,41 @@ def paths() -> AppPaths:
         logs=state / "logs",
         recent_projects=state / "recent-projects.json",
     )
+
+
+def atomic_write_text(destination: Path, text: str, *, mode: int | None = None) -> None:
+    """Replace ``destination`` via a temp file unique to this write.
+
+    A shared temp name lets concurrent processes move or clobber each other's
+    half-written file, so every write gets its own name in the same directory.
+    """
+    fd, name = tempfile.mkstemp(
+        prefix=f".{destination.name}.", suffix=".tmp", dir=destination.parent
+    )
+    temporary = Path(name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(text)
+        if mode is not None:
+            temporary.chmod(mode)
+        temporary.replace(destination)
+    except BaseException:
+        with contextlib.suppress(OSError):
+            temporary.unlink()
+        raise
+
+
+@contextlib.contextmanager
+def state_lock(destination: Path) -> Generator[None]:
+    """Serialize read-modify-write of a state file across processes (POSIX only)."""
+    if sys.platform == "win32":
+        yield
+        return
+    import fcntl
+
+    with open(destination.with_name(f".{destination.name}.lock"), "a") as handle:
+        fcntl.flock(handle, fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(handle, fcntl.LOCK_UN)

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_graph.py

@@ -216,6 +216,8 @@ class _TurnRun:
         self.context_parts: list[str] = []
         self.failure: ErrorInfo | None = None
         self.cancelled = False
+        # The hosted service ended the turn with ``success: false``.
+        self.final_failed = False
 
     # ------------------------------------------------------------ streaming
 
@@ -244,6 +246,8 @@ class _TurnRun:
             self._track(event)
 
     def _track(self, event: CopperEvent) -> None:
+        if event.kind is EventKind.FINAL and isinstance(event.data, dict):
+            self.final_failed = event.data.get("success") is False or bool(event.data.get("error"))
         if event.kind is EventKind.TEXT:
             self.text.append(str(event.data))
         elif event.kind is EventKind.STATUS_EVENT and isinstance(event.data, dict):
@@ -426,6 +430,8 @@ class _TurnRun:
             ]
             if not await self.run_with_retry(continuation, first_messages=messages):
                 return False
+            if self.final_failed:
+                return False
         return True
 
     # ---------------------------------------------------------------- close
@@ -526,10 +532,12 @@ async def create_copper_graph(agent: CopperPilotAgent) -> Any:
                 query if isinstance(query, str) else json.dumps(query),
                 first_messages=original,
             )
-            if completed:
+            # A failed final ends the turn: waiting on background shells first
+            # would hold the hosted error back for as long as they run.
+            if completed and not run.final_failed:
                 await run.wait_for_background()
         finally:
-            if run.failure is not None or run.cancelled:
+            if run.failure is not None or run.cancelled or run.final_failed:
                 manager = _background_manager(agent)
                 if manager is not None:
                     await manager.kill_all()

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_preferences.py

@@ -7,7 +7,7 @@ import stat
 from pathlib import Path
 from typing import Any
 
-from copper_pilot_cli.copper_config import paths
+from copper_pilot_cli.copper_config import atomic_write_text, paths
 from copper_pilot_cli.copper_tools import ApprovalMode
 
 YOLO_ACK_VERSION = 1
@@ -30,10 +30,7 @@ def save_preferences(value: dict[str, Any]) -> None:
     destination = _path()
     destination.parent.mkdir(parents=True, exist_ok=True)
     destination.parent.chmod(stat.S_IRWXU)
-    temporary = destination.with_suffix(".tmp")
-    temporary.write_text(json.dumps(value, indent=2), encoding="utf-8")
-    temporary.chmod(stat.S_IRUSR | stat.S_IWUSR)
-    temporary.replace(destination)
+    atomic_write_text(destination, json.dumps(value, indent=2), mode=stat.S_IRUSR | stat.S_IWUSR)
 
 
 def saved_approval_mode() -> ApprovalMode:

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_protocol.py

@@ -6,6 +6,7 @@ import asyncio
 import hashlib
 import json
 import logging
+import os
 import re
 import ssl
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Sequence
@@ -37,6 +38,34 @@ MAX_CONTEXT_MESSAGE_BYTES = 64 * 1024
 MAX_CONTEXT_TOTAL_BYTES = 4 * 1024 * 1024
 MAX_CONTEXT_ENTRIES = 2_000
 MAX_STREAM_BYTES = 64 * 1024 * 1024
+# Request fields the hosted service echoes back in every chat_response. The
+# client never reads them, and the echoed ``query`` alone (a whole validate
+# prompt) can be most of each frame, so they do not count toward the budget.
+ECHOED_REQUEST_FIELDS = (
+    "query",
+    "context",
+    "document_context",
+    "pcb_data",
+    "pcb_info",
+    "schematic_data",
+    "schematic_info",
+)
+MAX_STATUS_BYTES = 16 * 1024
+# The answer itself can be long (a validate review's findings JSON easily
+# passes 16 KB) and the hosted side may send it as one frame.
+MAX_RESPONSE_TEXT_BYTES = 1024 * 1024
+IDLE_FRAME_TIMEOUT_ENV = "COPPER_PILOT_IDLE_TIMEOUT_SECONDS"
+DEFAULT_IDLE_FRAME_TIMEOUT = 10 * 60.0
+
+
+def idle_frame_timeout() -> float | None:
+    """Seconds a streaming turn may stay silent; ``None`` (env ``0``) waits forever."""
+    raw = os.getenv(IDLE_FRAME_TIMEOUT_ENV, "").strip()
+    try:
+        value = float(raw) if raw else DEFAULT_IDLE_FRAME_TIMEOUT
+    except ValueError:
+        value = DEFAULT_IDLE_FRAME_TIMEOUT
+    return value if value > 0 else None
 
 
 class ProtocolError(RuntimeError):
@@ -414,7 +443,7 @@ def websocket_url(base_url: str, *, agentic: bool = True) -> str:
     return urlunparse((scheme, parsed.netloc, path, "", "", ""))
 
 
-def sanitize_status(value: str) -> str:
+def sanitize_status(value: str, limit: int = MAX_STATUS_BYTES) -> str:
     """Convert hosted status HTML to bounded terminal-safe plain markdown."""
     safe = re.sub(
         r"<(?:script|style)\b[^>]*>[\s\S]*?</(?:script|style)>",
@@ -429,7 +458,7 @@ def sanitize_status(value: str) -> str:
     )
     text = _TERMINAL_ESCAPE.sub("", text)
     text = "".join(character for character in text if character in "\n\t" or ord(character) >= 32)
-    return _truncate_utf8(text, 16 * 1024)
+    return _truncate_utf8(text, limit)
 
 
 def usage_reset_time(frame: dict[str, Any]) -> str | None:
@@ -457,6 +486,20 @@ def error_message(value: Any) -> str:
 ToolHandler = Callable[[ToolRequest], Awaitable[Any]]
 
 
+def _counted_frame_bytes(raw: str | bytes, frame: dict[str, Any]) -> int:
+    """Bytes of one frame that count toward the stream budget, minus echoed request fields."""
+    size = len(raw.encode() if isinstance(raw, str) else raw)
+    response = frame.get("chat_response")
+    if isinstance(response, dict):
+        echoed = sum(
+            len(json.dumps(response[key]).encode())
+            for key in ECHOED_REQUEST_FIELDS
+            if key in response
+        )
+        size -= echoed
+    return max(size, 0)
+
+
 def tool_error_result(exc: BaseException) -> dict[str, Any]:
     """The tool_result payload reported when a local tool raises."""
     return {
@@ -489,10 +532,11 @@ class HostedChatClient:
         self._socket: Any = None
         self._owner: str | None = None
         self.first_frame_timeout = 60.0
-        # The desktop client never times out between frames once a turn is
-        # streaming: long hosted reasoning or subagent runs can stay silent for
-        # many minutes while websocket keepalive still detects dead peers.
-        self.idle_frame_timeout: float | None = None
+        # Long hosted reasoning or subagent runs can stay silent for minutes,
+        # and websocket keepalive only detects a dead peer. A server that keeps
+        # the socket open but stops sending would otherwise hang the turn
+        # forever, so a generous idle bound turns that stall into an error.
+        self.idle_frame_timeout: float | None = idle_frame_timeout()
         self.frame_budget = 10_000
 
     async def cancel(self) -> None:
@@ -582,7 +626,10 @@ class HostedChatClient:
                         raw = await asyncio.wait_for(socket.recv(), timeout)
                     except TimeoutError as exc:
                         phase = "first frame" if frame_count == 0 else "next frame"
-                        message = f"Timed out waiting for the hosted chat {phase}."
+                        message = (
+                            f"Timed out waiting for the hosted chat {phase} "
+                            f"(no data for {timeout:g} s)."
+                        )
                         raise ProtocolError(
                             message,
                             code="CHAT_FIRST_FRAME_TIMEOUT"
@@ -594,17 +641,22 @@ class HostedChatClient:
                         closed = exc
                         break
                     frame_count += 1
-                    stream_bytes += len(raw.encode() if isinstance(raw, str) else raw)
                     if frame_count > self.frame_budget:
                         raise ProtocolError("Chat exceeded the client frame budget.")
-                    if stream_bytes > MAX_STREAM_BYTES:
-                        raise ProtocolError("Chat exceeded the client stream byte budget.")
                     try:
                         frame = json.loads(raw)
                     except (json.JSONDecodeError, TypeError) as exc:
                         raise ProtocolError("Hosted chat returned invalid JSON.") from exc
                     if not isinstance(frame, dict):
                         raise ProtocolError("Hosted chat frame must be a JSON object.")
+                    stream_bytes += _counted_frame_bytes(raw, frame)
+                    if stream_bytes > MAX_STREAM_BYTES:
+                        raise ProtocolError(
+                            "Chat exceeded the client stream byte budget "
+                            f"({stream_bytes // (1024 * 1024)} MiB of hosted output "
+                            f"in {frame_count} frames, limit "
+                            f"{MAX_STREAM_BYTES // (1024 * 1024)} MiB)."
+                        )
                     frame_type = frame.get("type")
                     if frame_type == "error":
                         message = frame.get("public_message") or frame.get("message")
@@ -647,7 +699,9 @@ class HostedChatClient:
                     }
                     if response.response:
                         yield CopperEvent(
-                            EventKind.TEXT, sanitize_status(response.response), **metadata
+                            EventKind.TEXT,
+                            sanitize_status(response.response, MAX_RESPONSE_TEXT_BYTES),
+                            **metadata,
                         )
                     if response.reasoning_update:
                         yield CopperEvent(
@@ -741,6 +795,15 @@ class HostedChatClient:
                             break
                     if frame_type == "final" or response.is_final:
                         saw_final = True
+                        if response.success is False or response.error:
+                            logger.warning(
+                                "Hosted turn ended unsuccessfully (turn_id=%s, error=%r, "
+                                "frame keys=%s, extra fields=%s)",
+                                response.turn_id,
+                                response.error,
+                                sorted(frame),
+                                sorted(response.model_extra or {}),
+                            )
                         yield CopperEvent(
                             EventKind.FINAL,
                             {

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/copper_workspace.py

@@ -3,11 +3,14 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 from dataclasses import asdict, dataclass
 from pathlib import Path
 
-from copper_pilot_cli.copper_config import paths
+from copper_pilot_cli.copper_config import atomic_write_text, paths, state_lock
+
+logger = logging.getLogger(__name__)
 
 IGNORED_NAMES = {
     ".git",
@@ -117,22 +120,28 @@ def build_initial_file_tree(root: Path, limit: int = 2_000) -> str:
 
 
 def remember_workspace(context: WorkspaceContext, limit: int = 20) -> None:
-    """Persist most-recently-used folders atomically."""
+    """Persist most-recently-used folders atomically.
+
+    Best-effort bookkeeping: a failure here is logged, never raised, so it
+    cannot fail the session that triggered it.
+    """
     destination = paths().recent_projects
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    existing: list[dict[str, object]] = []
     try:
-        loaded = json.loads(destination.read_text())
-        if isinstance(loaded, list):
-            existing = [row for row in loaded if isinstance(row, dict)]
-    except (FileNotFoundError, OSError, json.JSONDecodeError):
-        pass
-    root = str(context.root)
-    rows = [{"root": root, **asdict(context)}]
-    rows.extend(row for row in existing if row.get("root") != root)
-    temporary = destination.with_suffix(".tmp")
-    temporary.write_text(json.dumps(rows[:limit], default=str, indent=2))
-    temporary.replace(destination)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        with state_lock(destination):
+            existing: list[dict[str, object]] = []
+            try:
+                loaded = json.loads(destination.read_text())
+                if isinstance(loaded, list):
+                    existing = [row for row in loaded if isinstance(row, dict)]
+            except (FileNotFoundError, OSError, json.JSONDecodeError):
+                pass
+            root = str(context.root)
+            rows = [{"root": root, **asdict(context)}]
+            rows.extend(row for row in existing if row.get("root") != root)
+            atomic_write_text(destination, json.dumps(rows[:limit], default=str, indent=2))
+    except OSError:
+        logger.warning("Could not update recent projects at %s", destination, exc_info=True)
 
 
 def recent_workspaces() -> list[Path]:

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/validate/design.py

@@ -283,6 +283,22 @@ class DesignIndex:
     def net_names(self) -> set[str]:
         return {name.upper() for name in self.nets}
 
+    def has_net(self, name: str) -> bool:
+        """Whether ``name`` cites a design net, by full path or hierarchical leaf.
+
+        KiCad names a local or hierarchical label's net with its sheet path
+        (``/RAIL_IO_3``, ``/power/RAIL_IO_3``) while people cite the label
+        (``RAIL_IO_3``). Accept the full name or any ``/``-boundary suffix of it.
+        """
+        cited = name.strip().upper()
+        if not cited:
+            return False
+        for net in self.nets:
+            full = net.upper()
+            if full == cited or full.endswith("/" + cited.lstrip("/")):
+                return True
+        return False
+
     @property
     def layer_names(self) -> set[str]:
         return {name.lower() for name in self.layers}

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/src/copper_pilot_cli/validate/reviewer.py

@@ -205,9 +205,12 @@ class HostedTurnRunner:
                         )
                     elif kind == EventKind.FINAL.value and isinstance(payload, dict):
                         if payload.get("success") is False or payload.get("error"):
-                            result.error = result.error or {
-                                "message": str(payload.get("error") or "hosted turn failed")
-                            }
+                            message = str(payload.get("error") or "hosted turn failed")
+                            # The hosted copy is generic; the turn id lets the
+                            # service owners find the server-side cause.
+                            if data.get("turn_id"):
+                                message = f"{message} (hosted turn {data['turn_id']})"
+                            result.error = result.error or {"message": message}
             except BaseException:
                 await runtime.acancel()
                 raise
@@ -460,7 +463,7 @@ def ground_findings(findings: list[Finding], index: DesignIndex | None) -> list[
                 problems.append("design index unavailable")
         else:
             missing_refs = [ref for ref in loc.refs if ref.upper() not in index.refs]
-            missing_nets = [net for net in loc.nets if net.upper() not in index.net_names]
+            missing_nets = [net for net in loc.nets if not index.has_net(net)]
             if missing_refs:
                 problems.append(f"unknown refs {', '.join(missing_refs)}")
             if missing_nets:

{copper_pilot_cli-0.1.11 → copper_pilot_cli-1.0.0}/tests/test_acp.py

@@ -826,6 +826,24 @@ async def test_prompt_reports_failed_final_event(tmp_path, monkeypatch) -> None:
         await agent.prompt(session_id=session_id, prompt=[TextContentBlock(type="text", text="x")])
 
 
+async def test_failed_final_event_names_the_hosted_turn(tmp_path, monkeypatch) -> None:
+    # The hosted copy is the generic "CopperPilot ran into an error."; the turn
+    # id is what lets the service owners find the server-side cause.
+    runtime = FakeRuntime(
+        [
+            {
+                "type": "copper.final",
+                "data": {"success": False, "error": "CopperPilot ran into an error."},
+                "turn_id": "turn-42",
+            }
+        ]
+    )
+    agent, _conn, _runtime, session_id = await _connected_agent(tmp_path, monkeypatch, runtime)
+    with pytest.raises(RequestError) as caught:
+        await agent.prompt(session_id=session_id, prompt=[TextContentBlock(type="text", text="x")])
+    assert str(caught.value) == "CopperPilot ran into an error. (hosted turn turn-42)"
+
+
 @pytest.mark.parametrize(
     ("error", "code"),
     [