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

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

@@ -1,14 +1,19 @@
 Metadata-Version: 2.4
 Name: bamboo-coding
-Version: 0.1.8
+Version: 0.2.1
 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.1}/pyproject.toml

@@ -4,16 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bamboo-coding"
-version = "0.1.8"
+version = "0.2.1"
 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.1}/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.1}/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.1}/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.1/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.1/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.1}/src/bamboo_coding/config.py

@@ -34,6 +34,9 @@ class AgentConfig:
     token_path: Path
     journal_path: Path
     config_path: Path = field(default_factory=Path)
+    # Server-side login account that owns this client. Empty string = public:
+    # every logged-in user sees (and may approve) the pending registration.
+    user: str = ""
     profile: str = DEFAULT_PROFILE
     profile_exists: bool = True
     legacy_client_section: bool = False
@@ -208,6 +211,7 @@ def load_config(profile: str | None = None) -> AgentConfig:
     hostname = _first_env("BAMBOO_CODING_HOSTNAME", "AGENT_HOSTNAME") or str(
         section.get("hostname") or platform.node() or client_id
     )
+    user = _first_env("BAMBOO_CODING_USER") or str(section.get("user") or "")
     version = _first_env("BAMBOO_CODING_VERSION", "AGENT_VERSION") or str(section.get("version") or _default_version())
     allowed_roots = _coerce_allowed_roots(
         _first_env("BAMBOO_CODING_ALLOWED_ROOTS", "AGENT_ALLOWED_ROOTS", "AGENT_ROOT", "AGENT_REPO_PATH")
@@ -259,6 +263,7 @@ def load_config(profile: str | None = None) -> AgentConfig:
         controller_url=controller_url,
         client_id=client_id,
         hostname=hostname,
+        user=user,
         version=version,
         token=token,
         token_path=token_path,

{bamboo_coding-0.1.8 → bamboo_coding-0.2.1}/src/bamboo_coding/controller_client.py

@@ -74,7 +74,14 @@ class ControllerConnection:
         return self.websocket
 
     async def send_register(self, message: AgentRegisterMessage) -> dict:
-        await self._send(message.model_dump())
+        payload = message.model_dump()
+        # Old servers forbid unknown keys (extra: "forbid") and model_dump()
+        # emits every field, including None defaults; only send owner_user
+        # when it is actually set, so a new client with no owner keeps
+        # working against an old server.
+        if payload.get("owner_user") is None:
+            payload.pop("owner_user", None)
+        await self._send(payload)
         return await self._receive()
 
     async def send_status(self, message: ClientStatusMessage) -> bool:

{bamboo_coding-0.1.8 → bamboo_coding-0.2.1}/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,13 +225,14 @@ 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,
             queued_tasks=queued,
             max_concurrent_tasks=max_concurrent,
             connected=True,
+            owner_user=self.config.user or None,
         )
         registration = await self.connection.send_register(register)
         self.last_registration_message = str(registration.get("message") or "")
@@ -567,7 +571,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(),
@@ -681,6 +685,11 @@ def build_parser() -> argparse.ArgumentParser:
     setup_parser.add_argument("--root", action="append", dest="roots", help="Allowed root path; pass more than once for multiple roots")
     setup_parser.add_argument("--client-id", help="Client identifier advertised to the controller")
     setup_parser.add_argument("--hostname", help="Hostname advertised to the controller")
+    setup_parser.add_argument(
+        "--user",
+        help="Server login account that owns this client; only that user sees "
+        "and approves it. Blank = every user.",
+    )
     setup_parser.add_argument("--force", action="store_true", help="Overwrite the profile if it already exists")
 
     run_parser = subparsers.add_parser("run", help="Run the Bamboo Coding client")
@@ -721,6 +730,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,12 +787,16 @@ 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())])
     ]
     default_client_id = args.client_id or config.client_id
     default_controller_url = args.controller_url or config.controller_url
+    default_user = args.user if args.user is not None else config.user
 
     if interactive:
         if profile_in_new_layout:
@@ -796,6 +812,7 @@ def setup_command(args: argparse.Namespace) -> int:
         client_id = _prompt("Client ID", default_client_id)
         default_hostname = args.hostname or config.hostname or client_id
         hostname = _prompt("Hostname", default_hostname)
+        owner_user = _prompt("Owner user (optional, blank = everyone)", default_user)
         allowed_roots = _prompt_roots(default_roots)
 
         roots_text = ", ".join(allowed_roots) if allowed_roots else "(none)"
@@ -804,6 +821,7 @@ def setup_command(args: argparse.Namespace) -> int:
         print(f"  Controller URL : {controller_url}")
         print(f"  Client ID      : {client_id}")
         print(f"  Hostname       : {hostname}")
+        print(f"  Owner user     : {owner_user or '(everyone)'}")
         print(f"  Allowed roots  : {roots_text}")
         print()
         if not _confirm(f"Write profile '{profile}' to {config_path}?", default_yes=True):
@@ -813,6 +831,7 @@ def setup_command(args: argparse.Namespace) -> int:
         controller_url = default_controller_url
         client_id = default_client_id
         hostname = args.hostname or config.hostname or client_id
+        owner_user = default_user
         allowed_roots = default_roots
 
     raw_config = _load_toml(config_path) if config_path.exists() else {}
@@ -829,6 +848,9 @@ def setup_command(args: argparse.Namespace) -> int:
         "allowed_roots": list(allowed_roots),
         "max_concurrent_tasks": config.max_concurrent_tasks,
     }
+    # Written only when set, keeping TOML files of non-users unchanged.
+    if owner_user:
+        servers[profile]["user"] = owner_user
 
     migrated_files: list[Path] = []
     creating_default_in_new_layout = (
@@ -866,7 +888,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 +997,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 +1049,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 +1077,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.1}/src/bamboo_coding/protocol.py

@@ -99,6 +99,9 @@ class AgentRegisterMessage(ProtocolModel):
     protocol_version: int
     client_id: str | None = None
     client_info: ClientInfo
+    # Server-side login account that owns this client. Optional; None/empty
+    # means public: every user sees (and may approve) it.
+    owner_user: str | None = None
     capabilities: list[CapabilityDescriptor] = Field(default_factory=list)
     roots: list[RootDescriptor] = Field(default_factory=list)
     connectivity: ConnectivityState

{bamboo_coding-0.1.8 → bamboo_coding-0.2.1}/src/bamboo_coding/status.py

@@ -24,7 +24,7 @@ def _build_common_payload(*, client_id: str, hostname: str, version: str, platfo
     }
 
 
-def build_register_message(*, client_id: str, hostname: str, version: str, platform_name: str, capabilities: list[dict], roots: list[dict] | None = None, repositories: list[dict] | None = None, active_tasks: int, queued_tasks: int, max_concurrent_tasks: int, connected: bool = True) -> AgentRegisterMessage:
+def build_register_message(*, client_id: str, hostname: str, version: str, platform_name: str, capabilities: list[dict], roots: list[dict] | None = None, repositories: list[dict] | None = None, active_tasks: int, queued_tasks: int, max_concurrent_tasks: int, connected: bool = True, owner_user: str | None = None) -> AgentRegisterMessage:
     payload = _build_common_payload(
         client_id=client_id,
         hostname=hostname,
@@ -38,6 +38,10 @@ def build_register_message(*, client_id: str, hostname: str, version: str, platf
         max_concurrent_tasks=max_concurrent_tasks,
         connected=connected,
     )
+    # Added only when non-empty: status messages never carry ownership, and
+    # an unset owner must not appear in the payload at all (see send_register).
+    if owner_user:
+        payload["owner_user"] = owner_user
     return AgentRegisterMessage(**payload)
 
 

{bamboo_coding-0.1.8 → bamboo_coding-0.2.1}/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.1}/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.1
 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.1}/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.1/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