pyclaudecli 1.0.3__tar.gz → 1.0.4__tar.gz

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyclaudecli
-Version: 1.0.3
+Version: 1.0.4
 Summary: Python library wrapping the Claude Code CLI: prompts, background agents, auth, MCP, plugins, and more
 Author-email: Suriya Ravichandran <suriyaravichandran@itrendsolution.com>
 License: MIT
@@ -9,7 +9,10 @@ Keywords: anthropic,automation,claude,claude-code,cli,sdk,wrapper
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
@@ -17,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -54,6 +58,10 @@ pip install pyclaudecli
 
 Requires the `claude` CLI itself to be installed and on `PATH` (see the [Claude Code docs](https://claude.com/claude-code)).
 
+Runs on Linux, macOS and Windows, Python 3.8+. On Windows the CLI is installed as
+`claude.cmd`, which `CreateProcess` won't find from a bare `"claude"` — the wrapper
+resolves it through `PATHEXT` for you, so the default `ClaudeCLI()` works there too.
+
 ## Quickstart
 
 ```python
@@ -456,6 +464,9 @@ auth lives with the `claude` CLI and your environment. Remember the argv of a ru
 process is visible to other users on the same machine via `ps`, so prefer env vars over
 flags for anything sensitive.
 
+Every call is an argv list on every platform — no shell, and no `shell=True` fallback on
+Windows, so quoting rules can't be turned into an injection.
+
 ## Development
 
 ```bash

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/README.md

@@ -31,6 +31,10 @@ pip install pyclaudecli
 
 Requires the `claude` CLI itself to be installed and on `PATH` (see the [Claude Code docs](https://claude.com/claude-code)).
 
+Runs on Linux, macOS and Windows, Python 3.8+. On Windows the CLI is installed as
+`claude.cmd`, which `CreateProcess` won't find from a bare `"claude"` — the wrapper
+resolves it through `PATHEXT` for you, so the default `ClaudeCLI()` works there too.
+
 ## Quickstart
 
 ```python
@@ -433,6 +437,9 @@ auth lives with the `claude` CLI and your environment. Remember the argv of a ru
 process is visible to other users on the same machine via `ps`, so prefer env vars over
 flags for anything sensitive.
 
+Every call is an argv list on every platform — no shell, and no `shell=True` fallback on
+Windows, so quoting rules can't be turned into an injection.
+
 ## Development
 
 ```bash

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyclaudecli"
-version = "1.0.3"
+version = "1.0.4"
 description = "Python library wrapping the Claude Code CLI: prompts, background agents, auth, MCP, plugins, and more"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -25,6 +25,10 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/src/pyclaudecli/__init__.py

@@ -3,7 +3,7 @@
 from .client import ClaudeCLI, build_flags
 from .exceptions import ClaudeCLIError, ClaudeNotFoundError, ClaudeTimeoutError
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 
 __all__ = [
     "ClaudeCLI",

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/src/pyclaudecli/_process.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import os
+import queue
 import re
-import select
+import shutil
 import subprocess
+import threading
 import time
 from dataclasses import dataclass
 from typing import Callable, Iterator, Optional, Sequence
@@ -69,6 +71,63 @@ def format_command(command: Sequence[str]) -> str:
     return " ".join(redact_command(command))
 
 
+def resolve_binary(binary: str, env: Optional[dict] = None) -> str:
+    """Finds the executable to run, the same way a shell would.
+
+    On Windows the `claude` CLI is an npm shim (`claude.cmd`), and
+    CreateProcess only ever appends `.exe` — so a bare "claude" is not found
+    unless it is resolved through PATHEXT first. `shutil.which` handles that,
+    and on POSIX it is a no-op beyond returning the absolute path.
+
+    Falls back to the name as given (an explicit path, or something the OS can
+    still resolve), so the usual ClaudeNotFoundError is what callers see.
+    """
+    if os.path.dirname(binary):
+        return binary
+    path = (env or os.environ).get("PATH")
+    return shutil.which(binary, path=path) or binary
+
+
+class _PipeReader:
+    """Reads a child's stdout from a thread, so waiting works everywhere.
+
+    `select` only accepts sockets on Windows, so it cannot be used to poll a
+    subprocess pipe. A daemon thread doing blocking reads is portable, and
+    still hands back partial output the moment it arrives — which matters for
+    a login prompt that never ends in a newline.
+    """
+
+    _EOF = object()
+
+    def __init__(self, fd: int) -> None:
+        self._fd = fd
+        self._chunks: "queue.Queue" = queue.Queue()
+        self._thread = threading.Thread(target=self._pump, daemon=True)
+        self._thread.start()
+
+    def _pump(self) -> None:
+        try:
+            while True:
+                data = os.read(self._fd, 4096)
+                if not data:
+                    break
+                self._chunks.put(data)
+        except (OSError, ValueError):
+            pass  # pipe closed underneath us; treated as EOF
+        finally:
+            self._chunks.put(self._EOF)
+
+    def read(self, timeout: float) -> Optional[str]:
+        """Returns decoded output, "" if nothing arrived in time, None at EOF."""
+        try:
+            item = self._chunks.get(timeout=timeout)
+        except queue.Empty:
+            return ""
+        if item is self._EOF:
+            return None
+        return item.decode("utf-8", errors="replace")
+
+
 @dataclass
 class CommandResult:
     args: list
@@ -91,7 +150,7 @@ def run(
     timeout: Optional[float] = None,
     check: bool = True,
 ) -> CommandResult:
-    command = [binary, *args]
+    command = [resolve_binary(binary, env), *args]
     try:
         completed = subprocess.run(
             command,
@@ -138,7 +197,7 @@ def stream_lines(
     env: Optional[dict] = None,
 ) -> Iterator[str]:
     """Runs a command and yields decoded stdout lines as they arrive."""
-    command = [binary, *args]
+    command = [resolve_binary(binary, env), *args]
     try:
         proc = subprocess.Popen(
             command,
@@ -182,7 +241,7 @@ def run_interactive(
     For subcommands that need a real terminal (attach, setup-token, an
     interactive mcp/import picker) rather than captured output.
     """
-    command = [binary, *args]
+    command = [resolve_binary(binary, env), *args]
     try:
         return subprocess.call(command, cwd=cwd, env=env)
     except FileNotFoundError as exc:
@@ -212,7 +271,7 @@ def oauth_login(
     found in the output so far. Falls back to `input()` if neither is given.
     Returns the child's exit code.
     """
-    command = [binary, *args]
+    command = [resolve_binary(binary, env), *args]
     try:
         proc = subprocess.Popen(
             command,
@@ -231,20 +290,22 @@ def oauth_login(
         ) from exc
 
     assert proc.stdout is not None and proc.stdin is not None
-    fd = proc.stdout.fileno()
+    # Send exactly "\n", not the platform line ending: on Windows text mode
+    # would translate it to "\r\n" and the CLI would read a stray CR.
+    if hasattr(proc.stdin, "reconfigure"):
+        proc.stdin.reconfigure(newline="\n")
+    reader = _PipeReader(proc.stdout.fileno())
     buffer = ""
     url: Optional[str] = None
     deadline = time.time() + timeout
 
     try:
         while time.time() < deadline and proc.poll() is None:
-            ready, _, _ = select.select([fd], [], [], 0.5)
-            if not ready:
-                continue
-
-            chunk = os.read(fd, 4096).decode(errors="replace")
-            if not chunk:
+            chunk = reader.read(0.5)
+            if chunk is None:  # the child closed its output
                 break
+            if not chunk:
+                continue
 
             buffer += chunk
             # A login that never reaches its prompt must not grow the buffer
@@ -289,21 +350,21 @@ def oauth_login(
 
         drain_deadline = time.time() + 30
         while proc.poll() is None and time.time() < drain_deadline:
-            ready, _, _ = select.select([fd], [], [], 0.5)
-            if ready:
-                chunk = os.read(fd, 4096).decode(errors="replace")
-                if not chunk:
-                    break
-                if on_output:
-                    on_output(chunk)
+            chunk = reader.read(0.5)
+            if chunk is None:
+                break
+            if chunk and on_output:
+                on_output(chunk)
 
-        if proc.poll() is None:
+        # Reaching EOF on stdout does not mean the child has exited yet, so
+        # give it a moment to actually finish rather than calling it a timeout.
+        try:
+            return proc.wait(timeout=max(drain_deadline - time.time(), 5))
+        except subprocess.TimeoutExpired:
             raise ClaudeTimeoutError(
                 f"'{format_command(command)}' did not finish after the code was submitted",
                 cmd=redact_command(command),
-            )
-
-        return proc.returncode
+            ) from None
     finally:
         # Never leave a half-driven login (or its pipes) behind, whatever
         # went wrong — including an exception raised by `code_provider`.

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/src/pyclaudecli/client.py

@@ -601,5 +601,6 @@ class ClaudeCLI:
         """
         import subprocess
 
-        args = [self.binary, "gateway", *build_flags({"config": config})]
-        return subprocess.Popen(args, cwd=self.cwd, env=self._env())
+        env = self._env()
+        args = [_process.resolve_binary(self.binary, env), "gateway", *build_flags({"config": config})]
+        return subprocess.Popen(args, cwd=self.cwd, env=env)

pyclaudecli-1.0.4/tests/test_portability.py

@@ -0,0 +1,206 @@
+"""Cross-platform behaviour: nothing here is POSIX-only or needs the claude CLI."""
+
+import os
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+from pyclaudecli import _process
+from pyclaudecli._process import _PipeReader, oauth_login, resolve_binary
+from pyclaudecli.exceptions import ClaudeTimeoutError
+
+
+# -- no POSIX-only polling ------------------------------------------------
+
+def test_module_does_not_use_select():
+    """`select` accepts only sockets on Windows, so pipes must not rely on it."""
+    assert not hasattr(_process, "select")
+
+
+def test_source_has_no_select_call():
+    import inspect
+
+    assert "select.select(" not in inspect.getsource(_process)
+
+
+# -- binary resolution ----------------------------------------------------
+
+def test_resolve_binary_finds_an_executable_on_path():
+    name = "cmd" if os.name == "nt" else "sh"
+    resolved = resolve_binary(name)
+    assert os.path.isabs(resolved)
+    assert os.path.exists(resolved)
+
+
+def test_resolve_binary_passes_through_unknown_names():
+    # Left as-is so the usual ClaudeNotFoundError is what the caller sees.
+    assert resolve_binary("definitely-not-installed-xyz") == "definitely-not-installed-xyz"
+
+
+def test_resolve_binary_leaves_explicit_paths_alone():
+    assert resolve_binary(sys.executable) == sys.executable
+    assert resolve_binary(os.path.join("some", "dir", "claude")) == os.path.join("some", "dir", "claude")
+
+
+def test_resolve_binary_honours_a_custom_path(tmp_path):
+    name = "fake-claude.bat" if os.name == "nt" else "fake-claude"
+    fake = tmp_path / name
+    fake.write_text("")
+    fake.chmod(0o755)
+    assert resolve_binary(name, {"PATH": str(tmp_path)}) == str(fake)
+
+
+# -- portable pipe reader -------------------------------------------------
+
+def test_pipe_reader_returns_partial_output():
+    read_fd, write_fd = os.pipe()
+    try:
+        os.write(write_fd, b"no trailing newline here")
+        reader = _PipeReader(read_fd)
+        assert reader.read(2.0) == "no trailing newline here"
+    finally:
+        os.close(write_fd)
+
+
+def test_pipe_reader_signals_eof_with_none():
+    read_fd, write_fd = os.pipe()
+    os.close(write_fd)
+    assert _PipeReader(read_fd).read(2.0) is None
+
+
+def test_pipe_reader_returns_empty_string_when_idle():
+    read_fd, write_fd = os.pipe()
+    try:
+        assert _PipeReader(read_fd).read(0.2) == ""
+    finally:
+        os.close(write_fd)
+        os.close(read_fd)
+
+
+# -- oauth_login driven against a stand-in CLI ----------------------------
+
+def write_fake_cli(tmp_path, body):
+    script = tmp_path / "fake_cli.py"
+    script.write_text(textwrap.dedent(body))
+    return script
+
+
+PROMPTING_CLI = '''
+    import sys
+    record = sys.argv[1]
+    sys.stdout.write("Open https://claude.ai/oauth/authorize?x=1 in your browser\\n")
+    sys.stdout.write("Paste code here: ")   # no newline, like the real prompt
+    sys.stdout.flush()
+    line = sys.stdin.readline()
+    with open(record, "w") as fh:
+        fh.write(repr(line))
+    sys.stdout.write("\\nLogged in\\n")
+    sys.exit(0)
+'''
+
+
+def test_oauth_login_completes_with_a_supplied_code(tmp_path):
+    record = tmp_path / "received.txt"
+    script = write_fake_cli(tmp_path, PROMPTING_CLI)
+
+    seen = []
+    rc = oauth_login(
+        sys.executable,
+        [str(script), str(record)],
+        code="123456",
+        on_output=seen.append,
+        timeout=30,
+    )
+
+    assert rc == 0
+    assert record.read_text() == repr("123456\n")   # exactly one line, no stray CR
+    assert "claude.ai/oauth" in "".join(seen)
+
+
+def test_oauth_login_passes_the_url_to_code_provider(tmp_path):
+    record = tmp_path / "received.txt"
+    script = write_fake_cli(tmp_path, PROMPTING_CLI)
+    urls = []
+
+    def provider(url):
+        urls.append(url)
+        return "abc999"
+
+    assert oauth_login(sys.executable, [str(script), str(record)],
+                       code_provider=provider, on_output=lambda _: None, timeout=30) == 0
+    assert urls and urls[0].startswith("https://claude.ai/oauth/authorize")
+    assert record.read_text() == repr("abc999\n")
+
+
+def test_oauth_login_sends_only_the_first_line(tmp_path):
+    record = tmp_path / "received.txt"
+    script = write_fake_cli(tmp_path, PROMPTING_CLI)
+
+    oauth_login(sys.executable, [str(script), str(record)],
+                code="code1\nrm -rf /\n", on_output=lambda _: None, timeout=30)
+
+    assert record.read_text() == repr("code1\n")
+
+
+def test_oauth_login_times_out_and_kills_the_child(tmp_path):
+    script = write_fake_cli(tmp_path, '''
+        import time
+        time.sleep(30)
+    ''')
+
+    with pytest.raises(ClaudeTimeoutError):
+        oauth_login(sys.executable, [str(script)], code="x",
+                    on_output=lambda _: None, timeout=1.5)
+
+
+def test_oauth_login_cleans_up_when_code_provider_raises(tmp_path):
+    record = tmp_path / "received.txt"
+    script = write_fake_cli(tmp_path, PROMPTING_CLI)
+
+    def boom(url):
+        raise RuntimeError("no code available")
+
+    with pytest.raises(RuntimeError):
+        oauth_login(sys.executable, [str(script), str(record)],
+                    code_provider=boom, on_output=lambda _: None, timeout=30)
+
+
+# -- the plain runners still work through the same resolution -------------
+
+def test_run_executes_a_resolved_binary(tmp_path):
+    script = write_fake_cli(tmp_path, '''
+        print("hello from the stand-in CLI")
+    ''')
+    result = _process.run(sys.executable, [str(script)])
+    assert result.ok
+    assert "hello from the stand-in CLI" in result.stdout
+
+
+def test_stream_lines_yields_output(tmp_path):
+    script = write_fake_cli(tmp_path, '''
+        for i in range(3):
+            print("line", i, flush=True)
+    ''')
+    lines = list(_process.stream_lines(sys.executable, [str(script)]))
+    assert lines == ["line 0", "line 1", "line 2"]
+
+
+def test_start_gateway_resolves_its_binary(monkeypatch):
+    """The gateway builds its own Popen, so it needs the same resolution."""
+    import subprocess as sp
+
+    from pyclaudecli import ClaudeCLI
+
+    seen = {}
+
+    def fake_popen(args, **kwargs):
+        seen["args"] = args
+        return object()
+
+    monkeypatch.setattr(sp, "Popen", fake_popen)
+    ClaudeCLI("sh" if os.name != "nt" else "cmd").start_gateway()
+
+    assert os.path.isabs(seen["args"][0])
+    assert seen["args"][1] == "gateway"

{pyclaudecli-1.0.3 → pyclaudecli-1.0.4}/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.8"
 
 [[package]]
 name = "pyclaudecli"
-version = "1.0.3"
+version = "1.0.4"
 source = { editable = "." }