pocketshell 0.4.22__tar.gz → 0.4.23__tar.gz

{pocketshell-0.4.22 → pocketshell-0.4.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pocketshell
-Version: 0.4.22
+Version: 0.4.23
 Summary: Unified server-side Python utility for the PocketShell Android client.
 Project-URL: Homepage, https://github.com/alexeygrigorev/pocketshell
 Project-URL: Issues, https://github.com/alexeygrigorev/pocketshell/issues

{pocketshell-0.4.22 → pocketshell-0.4.23}/pyproject.toml

@@ -8,7 +8,7 @@ name = "pocketshell"
 # scripts/check-pypi-version.sh enforces this; .github/workflows/build.yml
 # runs that check before publishing to PyPI. See
 # tools/pocketshell/README.md ("Release flow") for the bump procedure.
-version = "0.4.22"
+version = "0.4.23"
 description = "Unified server-side Python utility for the PocketShell Android client."
 readme = "README.md"
 requires-python = ">=3.11"

{pocketshell-0.4.22 → pocketshell-0.4.23}/src/pocketshell/agent_log.py

@@ -66,6 +66,16 @@ import click
 #          daemon consumer can tell "session id is wrong" apart from
 #          "binary is missing".
 _EXIT_LOG_NOT_FOUND = 66
+# Issue #1225/#1267: sentinel emitted in place of a transcript line that
+# exceeded ``--max-line-bytes``, immediately followed by the line's original
+# UTF-8 byte length. MUST stay byte-identical to ``LINE_TRUNCATION_SENTINEL``
+# in the Kotlin ``AgentConversationRepository`` so the app recognises it and
+# renders a VISIBLE truncation marker instead of feeding the (now absent)
+# oversized JSON to the parser. This is the Codex/OpenCode counterpart of the
+# ``awk`` per-line byte clamp #1225 applied to the Claude flat-JSONL tail: one
+# multi-megabyte rollout line (an inline base64 image, a huge ``tool_result``)
+# is degraded server-side so its bytes never cross SSH into the phone's heap.
+_LINE_TRUNCATION_SENTINEL = "@@PS_LINE_TRUNCATED@@"
 _DEFAULT_HANDOFF_MAX_TURNS = 30
 _DEFAULT_HANDOFF_MAX_CHARS = 20_000
 _HANDOFF_PROMPT = (
@@ -285,6 +295,28 @@ def _tail(lines: Iterable[str], n: Optional[int]) -> List[str]:
     return materialised[-n:]
 
 
+def _clamp_line_bytes(lines: List[str], max_line_bytes: Optional[int]) -> List[str]:
+    """Byte-bound each line, server-side, before it is emitted.
+
+    Any line whose UTF-8 byte length exceeds ``max_line_bytes`` is replaced by
+    ``<_LINE_TRUNCATION_SENTINEL><byte-length>`` so a single multi-megabyte
+    rollout line (an inline base64 image, a huge ``tool_result``) never crosses
+    SSH into the phone's heap — the Codex/OpenCode counterpart of the Claude
+    ``awk`` clamp (#1225/#1267). ``None`` or a non-positive cap disables the
+    clamp (the whole-file default); normal lines pass through verbatim.
+    """
+    if not max_line_bytes or max_line_bytes <= 0:
+        return lines
+    clamped: List[str] = []
+    for line in lines:
+        byte_length = len(line.encode("utf-8"))
+        if byte_length > max_line_bytes:
+            clamped.append(f"{_LINE_TRUNCATION_SENTINEL}{byte_length}")
+        else:
+            clamped.append(line)
+    return clamped
+
+
 def _parse_json_line(line: str) -> Optional[dict[str, Any]]:
     """Parse one JSONL row, returning ``None`` for malformed/partial rows."""
     try:
@@ -631,6 +663,18 @@ def _emit_json(
     is_flag=True,
     help="Emit a JSON envelope (`{engine, session, path, count, lines}`) instead of raw JSONL.",
 )
+@click.option(
+    "--max-line-bytes",
+    "max_line_bytes",
+    type=click.IntRange(min=0),
+    default=None,
+    help=(
+        "Replace any single log line longer than N bytes with a compact "
+        "truncation marker, server-side, so one multi-megabyte line (a pasted "
+        "image / huge tool result) cannot balloon the read into the client's "
+        "heap. Default: no clamp (emit lines verbatim)."
+    ),
+)
 @click.pass_context
 def agent_log_command(
     ctx: click.Context,
@@ -639,13 +683,16 @@ def agent_log_command(
     cwd: Optional[str],
     tail_count: Optional[int],
     json_output: bool,
+    max_line_bytes: Optional[int],
 ) -> None:
     """Print an agent JSONL conversation log.
 
     Reads the canonical per-engine path for the given session and emits
     the JSONL content either as raw lines (default) or wrapped in a JSON
     envelope (``--json``). ``--tail N`` bounds the output to the last N
-    events.
+    events. ``--max-line-bytes N`` degrades any single line longer than N
+    bytes to a compact truncation marker so one pathological line cannot
+    balloon the read (#1225/#1267).
 
     Exit codes:
 
@@ -679,7 +726,7 @@ def agent_log_command(
         )
         ctx.exit(_EXIT_LOG_NOT_FOUND)
 
-    lines = _tail(_read_lines(path), tail_count)
+    lines = _clamp_line_bytes(_tail(_read_lines(path), tail_count), max_line_bytes)
     if json_output:
         _emit_json(engine_normalised, session, path, lines)
     else:

{pocketshell-0.4.22 → pocketshell-0.4.23}/tests/test_agent_log.py

@@ -375,6 +375,112 @@ def test_json_envelope_with_tail(fake_home: Path) -> None:
     assert envelope["lines"] == [json.dumps(e, sort_keys=True) for e in events[-2:]]
 
 
+# ----- --max-line-bytes clamp (#1225/#1267) --------------------------
+
+
+def test_max_line_bytes_degrades_an_oversized_line_to_a_marker(fake_home: Path) -> None:
+    """A single multi-megabyte rollout line is replaced by
+    `@@PS_LINE_TRUNCATED@@<bytes>` server-side; normal lines pass through.
+
+    This is the Codex/OpenCode counterpart of the Claude `awk` byte clamp
+    (#1225): the oversized bytes never cross SSH into the phone's heap. The
+    Kotlin `AgentConversationRepository` recognises the marker and renders a
+    visible truncation note.
+    """
+    session = "clamp-session"
+    huge = "A" * (5 * 1024 * 1024)  # ~5 MB, far above a 256 KiB cap
+    events = [
+        {"type": "user", "message": "look at this"},
+        {"type": "assistant", "message": huge},
+        {"type": "assistant", "message": "seen"},
+    ]
+    log_path = (
+        fake_home / ".codex" / "sessions" / "2026" / "07" / "03" / f"{session}.jsonl"
+    )
+    _write_jsonl(log_path, events)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        agent_log_command,
+        [
+            "--engine",
+            "codex",
+            "--session",
+            session,
+            "--json",
+            "--max-line-bytes",
+            str(256 * 1024),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    envelope = json.loads(result.output)
+    lines = envelope["lines"]
+    assert len(lines) == 3
+    # The oversized line is a marker naming its original byte length; no envelope
+    # line exceeds the cap now.
+    marker = lines[1]
+    assert marker.startswith("@@PS_LINE_TRUNCATED@@")
+    original_bytes = len(json.dumps(events[1], sort_keys=True).encode("utf-8"))
+    assert marker == f"@@PS_LINE_TRUNCATED@@{original_bytes}"
+    assert all(len(line.encode("utf-8")) <= 256 * 1024 for line in lines)
+    # The normal turns around the pathological line are untouched.
+    assert lines[0] == json.dumps(events[0], sort_keys=True)
+    assert lines[2] == json.dumps(events[2], sort_keys=True)
+
+
+def test_max_line_bytes_leaves_a_normal_transcript_unchanged(fake_home: Path) -> None:
+    """Counter-pin: every line under the cap passes through verbatim, no marker."""
+    session = "clamp-normal"
+    events = _sample_events("c", count=4)
+    log_path = (
+        fake_home / ".codex" / "sessions" / "2026" / "07" / "03" / f"{session}.jsonl"
+    )
+    _write_jsonl(log_path, events)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        agent_log_command,
+        [
+            "--engine",
+            "codex",
+            "--session",
+            session,
+            "--json",
+            "--max-line-bytes",
+            str(256 * 1024),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    envelope = json.loads(result.output)
+    assert envelope["lines"] == [json.dumps(e, sort_keys=True) for e in events]
+    assert not any("@@PS_LINE_TRUNCATED@@" in line for line in envelope["lines"])
+
+
+def test_no_max_line_bytes_keeps_the_oversized_line_verbatim(fake_home: Path) -> None:
+    """Without the flag (the whole-file default) an oversized line is NOT clamped
+    — proving the clamp is what the flag opts into (the red state on base)."""
+    session = "clamp-off"
+    huge = "Z" * (300 * 1024)
+    events = [{"type": "assistant", "message": huge}]
+    log_path = (
+        fake_home / ".codex" / "sessions" / "2026" / "07" / "03" / f"{session}.jsonl"
+    )
+    _write_jsonl(log_path, events)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        agent_log_command,
+        ["--engine", "codex", "--session", session, "--json"],
+    )
+
+    assert result.exit_code == 0, result.output
+    envelope = json.loads(result.output)
+    assert envelope["lines"] == [json.dumps(events[0], sort_keys=True)]
+    assert "@@PS_LINE_TRUNCATED@@" not in result.output
+
+
 # ----- handoff export ------------------------------------------------