bamboo-coding 0.1.8__tar.gz → 0.2.0__tar.gz

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/PKG-INFO

@@ -1,14 +1,19 @@
 Metadata-Version: 2.4
 Name: bamboo-coding
-Version: 0.1.8
+Version: 0.2.0
 Summary: Bamboo Coding outbound client
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: gitpython==3.1.40
 Requires-Dist: websockets==13.1
 Requires-Dist: pydantic>=2.0
-Requires-Dist: bamboo-ssh
+Requires-Dist: bamboo-ssh>=0.2.0
 Requires-Dist: pyte>=0.8.2
+Requires-Dist: psutil>=5.9
+Requires-Dist: pywinpty>=2.0; sys_platform == "win32"
 
 # bamboo-coding
 

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/pyproject.toml

@@ -4,16 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bamboo-coding"
-version = "0.1.8"
+version = "0.2.0"
 description = "Bamboo Coding outbound client"
 readme = "README.md"
 requires-python = ">=3.12"
+classifiers = [
+  "Operating System :: POSIX :: Linux",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: MacOS",
+]
 dependencies = [
   "gitpython==3.1.40",
   "websockets==13.1",
   "pydantic>=2.0",
-  "bamboo-ssh",
+  "bamboo-ssh>=0.2.0",
   "pyte>=0.8.2",
+  "psutil>=5.9",
+  "pywinpty>=2.0; sys_platform == 'win32'",
 ]
 
 [project.scripts]

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding/agents/detection.py

@@ -4,6 +4,7 @@ import logging
 import os
 import shutil
 import subprocess
+import sys
 import threading
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -31,6 +32,10 @@ def resolve_bin(def_: AgentDef) -> str | None:
     """
     override = os.environ.get(f"BAMBOO_CODING_{def_.id.upper()}_BIN")
     if override:
+        if sys.platform == "win32":
+            # CreateProcess won't resolve `.cmd`/`.exe`-less names; which()
+            # honors PATHEXT and passes absolute paths through.
+            return shutil.which(override)
         return override if os.access(override, os.X_OK) else None
     for candidate in (def_.bin, *def_.fallback_bins):
         path = shutil.which(candidate)

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding/agents/runner.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import shutil
 
 from .streams import get_parser
 from .types import DetectedAgent, RuntimeContext
@@ -62,7 +63,11 @@ class AgentProcess:
     def build_argv(self) -> list[str]:
         def_ = self.detected.def_
         args = def_.build_args(self.model, self.extra_dirs, self.detected.caps, self.ctx)
-        return [self.detected.path, *args]
+        # Resolve right before the spawn: on Windows, CreateProcess does not
+        # resolve npm `.cmd` shims by itself; which() honors PATHEXT. On
+        # POSIX, which() on the already-absolute detected path is a no-op.
+        binary = shutil.which(self.detected.path) or self.detected.path
+        return [binary, *args]
 
     async def cancel(self) -> None:
         """SIGTERM the CLI (it flushes and exits); escalate to SIGKILL after a

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding/capabilities/repo.py

@@ -13,6 +13,9 @@ def _allowed_roots(repositories: dict[str, str] | list[str] | tuple[str, ...]) -
         values = list(repositories.values()) or list(repositories.keys())
     else:
         values = list(repositories)
+    # Guarantee: paths are resolved here, on the client that owns the
+    # filesystem. The server treats client paths as opaque, platform-tagged
+    # strings and never resolves them itself.
     return [str(Path(item).expanduser().resolve()) for item in values]
 
 

bamboo_coding-0.2.0/src/bamboo_coding/chat/pty_session.py

@@ -0,0 +1,15 @@
+"""Platform switch for ChatPtySession.
+
+On Windows the ConPTY-backed implementation is used; everywhere else the
+original Unix PTY implementation is imported unchanged (``pty_session_unix``
+is the old ``pty_session.py``, renamed without edits).
+"""
+
+import sys
+
+if sys.platform == "win32":
+    from .pty_session_win import ChatPtySession
+else:
+    from .pty_session_unix import ChatPtySession
+
+__all__ = ["ChatPtySession"]

bamboo_coding-0.2.0/src/bamboo_coding/chat/pty_session_win.py

@@ -0,0 +1,125 @@
+"""ConPTY-backed ChatPtySession for native Windows.
+
+Mirrors the shape of the Unix implementation (``master_fd``, ``process``,
+``closed``, ``start``/``write``/``resize``/``close``) so it composes with
+``bamboo_ssh.stream_terminal_output`` (whose Windows backend reads from the
+pywinpty handle stored in ``master_fd``).
+
+Unlike the shell-oriented ``bamboo_ssh`` session, this spawns an arbitrary
+argv directly. Windows specifics:
+
+- npm-installed CLIs are ``.cmd`` shims that ``CreateProcess`` does not
+  resolve by itself, so argv[0] is resolved with ``shutil.which`` (which
+  honors ``PATHEXT``) before spawning.
+- There are no process groups; ``close()`` terminates the process and then
+  uses ``taskkill /T /F`` to reap the whole child tree — the Windows
+  replacement for ``os.killpg``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from typing import Any
+
+_CLOSE_WAIT_SECONDS = 1.0
+
+
+class _ProcessAdapter:
+    """subprocess.Popen-ish view over a pywinpty PtyProcess."""
+
+    def __init__(self, pty_process: Any):
+        self._pty = pty_process
+
+    @property
+    def pid(self) -> int:
+        return self._pty.pid
+
+    @property
+    def returncode(self) -> int | None:
+        if self._pty.isalive():
+            return None
+        return self._pty.exitstatus
+
+    def poll(self) -> int | None:
+        return self.returncode
+
+    def wait(self, timeout: float | None = None) -> int | None:
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while self._pty.isalive():
+            if deadline is not None and time.monotonic() >= deadline:
+                return None
+            time.sleep(0.05)
+        return self._pty.exitstatus
+
+
+@dataclass
+class ChatPtySession:
+    # Named ``master_fd`` for interface compatibility with the unix backend;
+    # holds the pywinpty PtyProcess handle rather than a file descriptor.
+    master_fd: Any
+    process: _ProcessAdapter
+    closed: bool = False
+
+    @classmethod
+    def start(
+        cls,
+        *,
+        argv: list[str],
+        cwd: str | None = None,
+        cols: int = 120,
+        rows: int = 32,
+        env: dict[str, str] | None = None,
+    ) -> "ChatPtySession":
+        from winpty import PtyProcess  # pywinpty; Windows-only
+
+        if not argv:
+            raise ValueError("argv must not be empty")
+        merged_env = os.environ.copy()
+        merged_env.setdefault("TERM", "xterm-256color")
+        if env:
+            merged_env.update(env)
+        resolved = shutil.which(argv[0]) or argv[0]
+        pty_process = PtyProcess.spawn(
+            [resolved, *argv[1:]],
+            cwd=cwd or None,
+            env=merged_env,
+            dimensions=(rows, cols),
+        )
+        return cls(master_fd=pty_process, process=_ProcessAdapter(pty_process))
+
+    def write(self, data: str | bytes) -> None:
+        if self.closed:
+            return
+        payload = data.decode("utf-8", errors="replace") if isinstance(data, bytes) else data
+        self.master_fd.write(payload)
+
+    def resize(self, cols: int, rows: int) -> None:
+        if self.closed:
+            return
+        self.master_fd.setwinsize(rows, cols)
+
+    def close(self) -> None:
+        if self.closed:
+            return
+        self.closed = True
+        pid = self.master_fd.pid
+        with contextlib.suppress(Exception):
+            self.master_fd.terminate()
+        deadline = time.monotonic() + _CLOSE_WAIT_SECONDS
+        while self.master_fd.isalive() and time.monotonic() < deadline:
+            time.sleep(0.05)
+        if self.master_fd.isalive():
+            # Kill the whole child tree; grandchildren survive terminate().
+            with contextlib.suppress(Exception):
+                subprocess.run(
+                    ["taskkill", "/T", "/F", "/PID", str(pid)],
+                    capture_output=True,
+                    check=False,
+                )
+        with contextlib.suppress(Exception):
+            del self.master_fd.pty

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding/main.py

@@ -5,11 +5,14 @@ import asyncio
 import json
 import logging
 import os
+import platform as _platform
 import random
 import re
 import signal
 import sys
 import time
+
+import psutil
 from dataclasses import asdict
 from pathlib import Path
 from typing import Awaitable, Callable
@@ -222,7 +225,7 @@ class AgentRuntime:
             client_id=self.config.client_id,
             hostname=self.config.hostname,
             version=self.config.version,
-            platform_name="python",
+            platform_name=_platform.system().lower(),  # "linux" / "windows" / "darwin"
             capabilities=self.capabilities(),
             roots=self.roots(),
             active_tasks=active,
@@ -567,7 +570,7 @@ class AgentRuntime:
                         client_id=self.config.client_id,
                         hostname=self.config.hostname,
                         version=self.config.version,
-                        platform_name="python",
+                        platform_name=_platform.system().lower(),  # "linux" / "windows" / "darwin"
                         reason="task_update",
                         capabilities=self.capabilities(),
                         roots=self.roots(),
@@ -721,6 +724,9 @@ def _prompt(label: str, default: str) -> str:
 def _prompt_roots(default_roots: list[str]) -> list[str]:
     default_text = ", ".join(default_roots)
     raw = _prompt("Allowed roots (comma-separated)", default_text)
+    # Guarantee: roots leave the client absolute and resolved. The server
+    # treats client paths as opaque, platform-tagged strings and never
+    # resolves them itself.
     return [
         str(Path(item.strip()).expanduser().resolve())
         for item in raw.split(",")
@@ -775,6 +781,9 @@ def setup_command(args: argparse.Namespace) -> int:
         )
         return 1
 
+    # Guarantee: roots leave the client absolute and resolved. The server
+    # treats client paths as opaque, platform-tagged strings and never
+    # resolves them itself.
     default_roots = [
         str(Path(root).expanduser().resolve())
         for root in (args.roots or list(config.allowed_roots) or [str(Path.cwd().resolve())])
@@ -866,7 +875,10 @@ async def _run_runtime(runtime: AgentRuntime, stop_event: asyncio.Event | None =
     registered_signals: list[signal.Signals] = []
     if owns_signal_handlers:
         loop = asyncio.get_running_loop()
-        for signum in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP):
+        _signals = [signal.SIGINT, signal.SIGTERM]
+        if hasattr(signal, "SIGHUP"):  # not on Windows
+            _signals.append(signal.SIGHUP)
+        for signum in _signals:
             try:
                 loop.add_signal_handler(signum, stop_event.set)
                 registered_signals.append(signum)
@@ -972,60 +984,45 @@ def _is_bamboo_client(argv: list[str]) -> bool:
 
 
 def _find_running_clients() -> list[tuple[int, list[str]]]:
-    """Walk /proc to find running bamboo-coding client processes (Linux only)."""
+    """Find running bamboo-coding client processes via psutil (cross-platform)."""
     results: list[tuple[int, list[str]]] = []
-    proc_dir = Path("/proc")
-    if not proc_dir.exists():
-        return results
     self_pid = os.getpid()
-    for entry in proc_dir.iterdir():
-        if not entry.name.isdigit():
-            continue
-        pid = int(entry.name)
-        if pid == self_pid:
-            continue
-        try:
-            raw = (entry / "cmdline").read_bytes()
-        except (FileNotFoundError, PermissionError, OSError):
-            continue
-        if not raw:
+    for proc in psutil.process_iter(["pid", "cmdline"]):
+        pid = proc.info.get("pid")
+        if pid is None or pid == self_pid:
             continue
-        argv = [part.decode("utf-8", errors="replace") for part in raw.split(b"\x00") if part]
-        if _is_bamboo_client(argv):
+        argv = proc.info.get("cmdline") or []
+        if argv and _is_bamboo_client(argv):
             results.append((pid, argv))
     return results
 
 
 def _pid_alive(pid: int) -> bool:
     try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
+        # A zombie has already exited (its parent just hasn't reaped it) —
+        # counting it alive would make `stop` report a false failure.
+        return psutil.Process(pid).status() != psutil.STATUS_ZOMBIE
+    except psutil.NoSuchProcess:
         return False
-    except PermissionError:
+    except psutil.AccessDenied:
         return True
-    return True
+    except Exception:
+        return False
 
 
 def _lookup_client_argv(pid: int) -> list[str] | None:
     """Return argv for `pid` if it is a bamboo-coding client process, else None."""
     try:
-        raw = Path(f"/proc/{pid}/cmdline").read_bytes()
-    except (FileNotFoundError, PermissionError, OSError):
-        return None
-    if not raw:
+        argv = psutil.Process(pid).cmdline()
+    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess, OSError):
         return None
-    argv = [part.decode("utf-8", errors="replace") for part in raw.split(b"\x00") if part]
-    if not _is_bamboo_client(argv):
+    if not argv or not _is_bamboo_client(argv):
         return None
     return argv
 
 
 def status_command(args: argparse.Namespace) -> int:
     logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-    if sys.platform != "linux":
-        print("'bamboo-coding status' is only supported on Linux (it reads /proc).", file=sys.stderr)
-        return 2
-
     clients = _find_running_clients()
     if not clients:
         print("No running bamboo-coding clients found.")
@@ -1039,10 +1036,6 @@ def status_command(args: argparse.Namespace) -> int:
 
 def stop_command(args: argparse.Namespace) -> int:
     logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-    if sys.platform != "linux":
-        print("'bamboo-coding stop' is only supported on Linux (it reads /proc).", file=sys.stderr)
-        return 2
-
     requested_pids: list[int] = list(getattr(args, "pids", []) or [])
 
     if requested_pids:
@@ -1071,17 +1064,23 @@ def stop_command(args: argparse.Namespace) -> int:
     for pid, argv in clients:
         print(f"  PID {pid}: {' '.join(argv)}")
 
-    sig = signal.SIGKILL if args.force else signal.SIGTERM
+    # psutil kill()/terminate() replace SIGKILL/SIGTERM: SIGKILL does not
+    # exist on Windows, and psutil maps both calls to the right primitive
+    # on every OS.
     sig_name = "SIGKILL" if args.force else "SIGTERM"
     sent: list[int] = []
     for pid, _ in clients:
         try:
-            os.kill(pid, sig)
+            proc = psutil.Process(pid)
+            if args.force:
+                proc.kill()
+            else:
+                proc.terminate()
             sent.append(pid)
             print(f"Sent {sig_name} to PID {pid}")
-        except ProcessLookupError:
+        except psutil.NoSuchProcess:
             print(f"PID {pid} already exited")
-        except PermissionError:
+        except psutil.AccessDenied:
             print(f"Permission denied for PID {pid}; rerun with sudo")
 
     if not sent or args.force:

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding/terminal_runtime.py

@@ -5,6 +5,7 @@ import inspect
 import os
 import shlex
 import signal as _signal
+import sys
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -43,6 +44,11 @@ def build_initial_cwd_command(path: str) -> str:
     target = Path(path).expanduser()
     resolved = target.resolve(strict=False)
     working_dir = resolved if resolved.is_dir() else resolved.parent
+    if sys.platform == "win32":
+        # A `cd "..."` both PowerShell and cmd accept; embedded quotes are
+        # doubled, and the line ending is \r\n.
+        escaped = str(working_dir).replace('"', '""')
+        return f'cd "{escaped}"\r\n'
     return f"cd {shlex.quote(str(working_dir))}\n"
 
 
@@ -210,6 +216,21 @@ class ClientTerminalRuntime:
         active = self.sessions.get(message.terminal_id)
         if active is None:
             return
+        if sys.platform == "win32":
+            # No process groups or tcgetpgrp on Windows. Ctrl+C travels
+            # through the ConPTY input stream; SIGTERM closes the session
+            # (the win backend tears down the console tree itself).
+            if message.signal == "SIGINT":
+                try:
+                    active.session.write("\x03")
+                except Exception as exc:
+                    await self._emit(
+                        self.send_status,
+                        TerminalStatusMessage(terminal_id=message.terminal_id, status='error', message=str(exc)),
+                    )
+            else:
+                await self.close_terminal(message.terminal_id, reason='signalled')
+            return
         master_fd = active.session.master_fd
         try:
             pgid = os.tcgetpgrp(master_fd)

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding.egg-info/PKG-INFO

@@ -1,14 +1,19 @@
 Metadata-Version: 2.4
 Name: bamboo-coding
-Version: 0.1.8
+Version: 0.2.0
 Summary: Bamboo Coding outbound client
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: gitpython==3.1.40
 Requires-Dist: websockets==13.1
 Requires-Dist: pydantic>=2.0
-Requires-Dist: bamboo-ssh
+Requires-Dist: bamboo-ssh>=0.2.0
 Requires-Dist: pyte>=0.8.2
+Requires-Dist: psutil>=5.9
+Requires-Dist: pywinpty>=2.0; sys_platform == "win32"
 
 # bamboo-coding
 

{bamboo_coding-0.1.8 → bamboo_coding-0.2.0}/src/bamboo_coding.egg-info/SOURCES.txt

@@ -38,6 +38,8 @@ src/bamboo_coding/chat/__init__.py
 src/bamboo_coding/chat/__main__.py
 src/bamboo_coding/chat/adapter.py
 src/bamboo_coding/chat/pty_session.py
+src/bamboo_coding/chat/pty_session_unix.py
+src/bamboo_coding/chat/pty_session_win.py
 src/bamboo_coding/chat/runtime.py
 src/bamboo_coding/chat/session.py
 src/bamboo_coding/chat/types.py

bamboo_coding-0.2.0/src/bamboo_coding.egg-info/requires.txt

@@ -0,0 +1,9 @@
+gitpython==3.1.40
+websockets==13.1
+pydantic>=2.0
+bamboo-ssh>=0.2.0
+pyte>=0.8.2
+psutil>=5.9
+
+[:sys_platform == "win32"]
+pywinpty>=2.0

bamboo_coding-0.1.8/src/bamboo_coding.egg-info/requires.txt

@@ -1,5 +0,0 @@
-gitpython==3.1.40
-websockets==13.1
-pydantic>=2.0
-bamboo-ssh
-pyte>=0.8.2