lkr-dev-cli 0.0.40__tar.gz → 0.0.41__tar.gz

{lkr_dev_cli-0.0.40 → lkr_dev_cli-0.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.40
+Version: 0.0.41
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT

{lkr_dev_cli-0.0.40 → lkr_dev_cli-0.0.41}/codemode.md

@@ -47,5 +47,14 @@ To check things out on a web panel:
 npx @modelcontextprotocol/inspector uvx -q --from lkr-dev-cli[codemode] lkr code-mode run
 ```
 
-```
+## Architectural & Troubleshooting Notes
+
+### The stdio Stream Corruption Trap
+When running an MCP server over standard input/output (`stdio`) transport, JSON-RPC packets are transmitted directly through the process's `stdout`. 
+
+If Python code executed within the server (such as tool execution or third-party libraries) writes raw text directly to `sys.stdout` via standard `print()` calls, that raw text corrupts the JSON-RPC response stream. This causes fatal JSON parsing errors on the client (e.g., `invalid character 'C' looking for beginning of value`) and immediately closes the connection.
+
+To safeguard against this:
+1. `run_python_code` automatically wraps all Monty execution in a `redirect_stdout` block.
+2. If any `print()` output is captured, it is safely packaged and returned as part of a valid JSON structure rather than polluting raw `stdout`.
 

{lkr_dev_cli-0.0.40 → lkr_dev_cli-0.0.41}/lkr/codemode/main.py

@@ -1,7 +1,9 @@
 import inspect
-import io
 import json
-from contextlib import redirect_stdout
+import os
+import sys
+import tempfile
+from contextlib import contextmanager
 
 import typer
 import pydantic_monty
@@ -21,8 +23,38 @@ __all__ = ["group"]
 mcp = FastMCP("lkr:codemode")
 group = typer.Typer()
 ctx_lkr: LkrCtxObj | None = None
-
-
+class OSCapture:
+    def __init__(self):
+        self.output = ""
+
+@contextmanager
+def capture_os_stdout():
+    cap = OSCapture()
+    fd, temp_path = tempfile.mkstemp()
+    
+    if sys.stdout and hasattr(sys.stdout, "flush"):
+        sys.stdout.flush()
+        
+    original_stdout = sys.stdout
+    original_stdout_fd = os.dup(1)
+    try:
+        os.dup2(fd, 1)
+        with os.fdopen(os.dup(1), "w") as f:
+            sys.stdout = f
+            yield cap
+            f.flush()
+    finally:
+        sys.stdout = original_stdout
+        os.dup2(original_stdout_fd, 1)
+        os.close(original_stdout_fd)
+        os.close(fd)
+        
+        try:
+            with open(temp_path, "r") as f:
+                cap.output = f.read()
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
 
 def get_mcp_sdk(ctx: LkrCtxObj):
     sdk = get_auth(ctx).get_current_sdk(prompt_refresh_invalid_token=True)
@@ -126,13 +158,12 @@ def run_python_code(code: str, dev_mode: bool = False) -> str:
 
         m = pydantic_monty.Monty(code)
         
-        # Redirect stdout to capture any print() statements
-        # and prevent them from corrupting the JSON-RPC stream
-        f = io.StringIO()
-        with redirect_stdout(f):
+        # Use low-level OS stdout capture to ensure any print() statements
+        # in Rust or sub-interpreters don't corrupt the JSON-RPC stream
+        with capture_os_stdout() as cap:
             result = m.run(external_functions=external_funcs)
         
-        printed_output = f.getvalue()
+        printed_output = cap.output
         
         # m.run() returns the evaluated result of the last expression (which is already a primitive)
         try:
@@ -148,7 +179,10 @@ def run_python_code(code: str, dev_mode: bool = False) -> str:
             output = repr(result)
             
         if printed_output:
-            return f"PRINTED OUTPUT:\n{printed_output}\nRESULT:\n{output}"
+            return json.dumps({
+                "stdout": printed_output,
+                "result": result
+            }, indent=2, default=str)
         return output
     except Exception as e:
         logger.error(f"Error executing Monty: {e}")

{lkr_dev_cli-0.0.40 → lkr_dev_cli-0.0.41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lkr-dev-cli"
-version = "0.0.40"
+version = "0.0.41"
 description = "lkr: a command line interface for looker"
 readme = "README.md"
 license = "MIT"

{lkr_dev_cli-0.0.40 → lkr_dev_cli-0.0.41}/tests/test_codemode.py

@@ -1,4 +1,5 @@
 from typing import Any, cast
+import json
 import pytest
 from unittest.mock import patch, MagicMock
 from looker_sdk.rtl.auth_session import AuthSession
@@ -247,4 +248,38 @@ return lookup('ProjectCommitRequest')
     assert "Looker automatically stages and commits" in result_model
 
 
+def test_captured_print_json():
+    code = """
+print("Hello from stdout")
+return {"status": "success"}
+"""
+    result_raw = run_python_code(code)
+    data = json.loads(result_raw)
+    assert data["stdout"] == "Hello from stdout\n"
+    assert data["result"] == {"status": "success"}
+
+def test_captured_print_json_many():
+    code = """
+for i in range(10):
+    print(i)
+return {"status": "success"}
+"""
+    result_raw = run_python_code(code)
+    data = json.loads(result_raw)
+    assert data["stdout"] == "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"
+    assert data["result"] == {"status": "success"}
 
+
+def test_parent_runtime_not_polluted(capfd):
+    code = """
+print("This should be trapped and not leak to parent stdout")
+print("Also checking second print")
+return {"status": "clean"}
+"""
+    result_raw = run_python_code(code)
+    data = json.loads(result_raw)
+    assert "This should be trapped" in data["stdout"]
+    assert "Also checking" in data["stdout"]
+    
+    out, err = capfd.readouterr()
+    assert out == ""