bamboo-coding 0.1.0__tar.gz → 0.1.2__tar.gz

bamboo_coding-0.1.2/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: bamboo-coding
+Version: 0.1.2
+Summary: Bamboo Coding outbound client
+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
+
+# bamboo-coding
+
+Outbound client for the Bamboo Coding controller.
+
+## Install
+
+```bash
+pip install bamboo-coding
+```
+
+## Usage
+
+```bash
+bamboo-coding setup            # configure default profile
+bamboo-coding run              # connect to the controller
+```
+
+The client reads its configuration from `~/.bamboo-coding/bamboo-coding.toml`.

bamboo_coding-0.1.2/README.md

@@ -0,0 +1,18 @@
+# bamboo-coding
+
+Outbound client for the Bamboo Coding controller.
+
+## Install
+
+```bash
+pip install bamboo-coding
+```
+
+## Usage
+
+```bash
+bamboo-coding setup            # configure default profile
+bamboo-coding run              # connect to the controller
+```
+
+The client reads its configuration from `~/.bamboo-coding/bamboo-coding.toml`.

bamboo_coding-0.1.2/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bamboo-coding"
+version = "0.1.2"
+description = "Bamboo Coding outbound client"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+  "gitpython==3.1.40",
+  "websockets==13.1",
+  "pydantic>=2.0",
+  "bamboo-ssh",
+]
+
+[project.scripts]
+bamboo-coding = "bamboo_coding.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["bamboo_coding*"]

{bamboo_coding-0.1.0/bamboo_coding/client → bamboo_coding-0.1.2/src/bamboo_coding}/capabilities/repo.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Callable
 
-import git_utils
-from bamboo_coding.shared.protocol import TaskMessage
+from .. import git_utils
+from ..protocol import TaskMessage
 
 
 def _allowed_roots(repositories: dict[str, str] | list[str] | tuple[str, ...]) -> list[str]:
@@ -229,6 +229,19 @@ def _pull_remote(task: TaskMessage, repositories) -> dict:
     )
 
 
+def _search(task: TaskMessage, repositories) -> dict:
+    repo_path = _resolve_repo_root(task, repositories)
+    query = str(task.params.get("query", ""))
+    return git_utils.search_repository(
+        repo_path,
+        query,
+        case_sensitive=bool(task.params.get("case_sensitive", False)),
+        whole_word=bool(task.params.get("whole_word", False)),
+        regex=bool(task.params.get("regex", False)),
+        max_matches=int(task.params.get("max_matches", 1000)),
+    )
+
+
 _HANDLERS: dict[tuple[str, str], Callable[[TaskMessage, dict[str, str] | list[str] | tuple[str, ...]], dict]] = {
     ("fs.tree", "get"): _fs_tree,
     ("fs.browse", "get"): _fs_browse,
@@ -276,4 +289,6 @@ _HANDLERS: dict[tuple[str, str], Callable[[TaskMessage, dict[str, str] | list[st
     ("git.branches.delete", "delete"): _delete_branch,
     ("git.branches.merge", "post"): _merge_branch,
     ("git.commit.create", "post"): _create_commit,
+    ("git.search", "post"): _search,
+    ("repo.search", "post"): _search,
 }

{bamboo_coding-0.1.0/bamboo_coding/client → bamboo_coding-0.1.2/src/bamboo_coding}/config.py

@@ -13,6 +13,8 @@ DEFAULT_CONFIG_DIRNAME = ".bamboo-coding"
 DEFAULT_CONFIG_FILENAME = "bamboo-coding.toml"
 DEFAULT_CONTROLLER_URL = "ws://127.0.0.1:8100/ws/agents"
 DEFAULT_CLIENT_ID = "bamboo-coding-client"
+DEFAULT_PROFILE = "default"
+SERVERS_DIRNAME = "servers"
 
 
 @dataclass(frozen=True)
@@ -32,6 +34,10 @@ class AgentConfig:
     token_path: Path
     journal_path: Path
     config_path: Path = field(default_factory=Path)
+    profile: str = DEFAULT_PROFILE
+    profile_exists: bool = True
+    legacy_client_section: bool = False
+    available_profiles: tuple[str, ...] = field(default_factory=tuple)
     max_concurrent_tasks: int = 1
     allowed_roots: tuple[str, ...] = field(default_factory=tuple)
     repositories: tuple[RepositoryConfig, ...] = field(default_factory=tuple)
@@ -107,7 +113,39 @@ def _load_legacy_token(default_token_path: Path) -> str:
     return token
 
 
-def load_config() -> AgentConfig:
+def _resolve_profile_section(raw_config: dict, profile: str) -> tuple[dict | None, bool]:
+    """Return (profile_dict, is_legacy_client_section).
+
+    profile_dict is None if no matching profile was found.
+    """
+    servers = raw_config.get("servers")
+    if isinstance(servers, dict):
+        candidate = servers.get(profile)
+        if isinstance(candidate, dict):
+            return candidate, False
+    if profile == DEFAULT_PROFILE:
+        legacy = raw_config.get("client")
+        if isinstance(legacy, dict):
+            return legacy, True
+    return None, False
+
+
+def _list_available_profiles(raw_config: dict) -> tuple[str, ...]:
+    names: list[str] = []
+    servers = raw_config.get("servers")
+    if isinstance(servers, dict):
+        names.extend(name for name in servers if isinstance(servers.get(name), dict))
+    if DEFAULT_PROFILE not in names and isinstance(raw_config.get("client"), dict):
+        names.insert(0, DEFAULT_PROFILE)
+    return tuple(names)
+
+
+def _profile_storage_dir(storage_home: Path, profile: str) -> Path:
+    return storage_home / SERVERS_DIRNAME / profile
+
+
+def load_config(profile: str | None = None) -> AgentConfig:
+    active_profile = profile or DEFAULT_PROFILE
     config_home = Path(_first_env("BAMBOO_CODING_HOME") or (Path.home() / DEFAULT_CONFIG_DIRNAME)).expanduser().resolve()
     config_path = _resolve_path(
         _first_env("BAMBOO_CODING_CONFIG_PATH"),
@@ -115,45 +153,70 @@ def load_config() -> AgentConfig:
         base_dir=config_home,
     )
     raw_config = _load_toml(config_path)
-    client_config = raw_config.get("client") if isinstance(raw_config.get("client"), dict) else {}
-    storage_config = raw_config.get("storage") if isinstance(raw_config.get("storage"), dict) else {}
+    profile_section, is_legacy_client = _resolve_profile_section(raw_config, active_profile)
+    available_profiles = _list_available_profiles(raw_config)
+    profile_exists = profile_section is not None
+    section = profile_section if isinstance(profile_section, dict) else {}
+
+    explicit_new_layout = profile_exists and not is_legacy_client
+    storage_config = (
+        raw_config.get("storage")
+        if not explicit_new_layout and isinstance(raw_config.get("storage"), dict)
+        else {}
+    )
 
     storage_home_value = _first_env("BAMBOO_CODING_HOME", "AGENT_HOME")
     storage_home = Path(storage_home_value).expanduser().resolve() if storage_home_value else config_home
 
+    if explicit_new_layout:
+        profile_dir = _profile_storage_dir(storage_home, active_profile)
+        default_token_path = profile_dir / "token.json"
+        default_journal_path = profile_dir / "journal.db"
+    elif active_profile == DEFAULT_PROFILE:
+        default_token_path = storage_home / "token.json"
+        default_journal_path = storage_home / "journal.db"
+    else:
+        profile_dir = _profile_storage_dir(storage_home, active_profile)
+        default_token_path = profile_dir / "token.json"
+        default_journal_path = profile_dir / "journal.db"
+
     controller_url = _first_env("BAMBOO_CODING_CONTROLLER_URL", "CONTROLLER_URL") or str(
-        client_config.get("controller_url") or DEFAULT_CONTROLLER_URL
+        section.get("controller_url") or DEFAULT_CONTROLLER_URL
     )
     client_id = _first_env("BAMBOO_CODING_CLIENT_ID", "AGENT_CLIENT_ID") or str(
-        client_config.get("client_id") or platform.node() or DEFAULT_CLIENT_ID
+        section.get("client_id") or platform.node() or DEFAULT_CLIENT_ID
     )
     hostname = _first_env("BAMBOO_CODING_HOSTNAME", "AGENT_HOSTNAME") or str(
-        client_config.get("hostname") or platform.node() or client_id
+        section.get("hostname") or platform.node() or client_id
     )
-    version = _first_env("BAMBOO_CODING_VERSION", "AGENT_VERSION") or str(client_config.get("version") or _default_version())
+    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")
-        or client_config.get("allowed_roots")
+        or section.get("allowed_roots")
     )
     max_concurrent_tasks = int(
         _first_env("BAMBOO_CODING_MAX_CONCURRENT_TASKS", "AGENT_MAX_CONCURRENT_TASKS")
-        or client_config.get("max_concurrent_tasks")
+        or section.get("max_concurrent_tasks")
         or 1
     )
 
     token_path = _resolve_path(
         _first_env("BAMBOO_CODING_TOKEN_PATH", "AGENT_TOKEN_PATH") or storage_config.get("token_path"),
-        default=storage_home / "token.json",
+        default=default_token_path,
         base_dir=config_path.parent,
     )
     journal_path = _resolve_path(
         _first_env("BAMBOO_CODING_JOURNAL_PATH", "AGENT_JOURNAL_PATH") or storage_config.get("journal_path"),
-        default=storage_home / "journal.db",
+        default=default_journal_path,
         base_dir=config_path.parent,
     )
 
     token = _first_env("BAMBOO_CODING_TOKEN", "AGENT_TOKEN") or _load_stored_token(token_path)
-    if not token and not _first_env("BAMBOO_CODING_TOKEN_PATH", "AGENT_TOKEN_PATH", "AGENT_HOME"):
+    if (
+        not token
+        and active_profile == DEFAULT_PROFILE
+        and not _first_env("BAMBOO_CODING_TOKEN_PATH", "AGENT_TOKEN_PATH", "AGENT_HOME")
+    ):
         token = _load_legacy_token(token_path)
 
     repositories = tuple(
@@ -173,6 +236,10 @@ def load_config() -> AgentConfig:
         token_path=token_path,
         journal_path=journal_path,
         config_path=config_path,
+        profile=active_profile,
+        profile_exists=profile_exists,
+        legacy_client_section=is_legacy_client,
+        available_profiles=available_profiles,
         max_concurrent_tasks=max_concurrent_tasks,
         allowed_roots=allowed_roots,
         repositories=repositories,

{bamboo_coding-0.1.0/bamboo_coding/client → bamboo_coding-0.1.2/src/bamboo_coding}/controller_client.py

@@ -2,12 +2,16 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 from typing import Awaitable, Callable
 
 from websockets import connect
 from websockets.exceptions import ConnectionClosed
 
-from bamboo_coding.shared.protocol import (
+
+LOGGER = logging.getLogger(__name__)
+
+from .protocol import (
     AgentRegisterMessage,
     ClientStatusMessage,
     TaskEventMessage,
@@ -17,15 +21,27 @@ from bamboo_coding.shared.protocol import (
     TerminalCloseMessage,
     TerminalInputMessage,
     TerminalHeartbeatMessage,
+    TerminalKillMessage,
+    TerminalListRequest,
+    TerminalListResponse,
     TerminalOpenMessage,
     TerminalOutputMessage,
     TerminalResizeMessage,
+    TerminalSignalMessage,
     TerminalStatusMessage,
     TerminalClosedMessage,
 )
 
 
-TerminalControlMessage = TerminalOpenMessage | TerminalInputMessage | TerminalResizeMessage | TerminalCloseMessage
+TerminalControlMessage = (
+    TerminalOpenMessage
+    | TerminalInputMessage
+    | TerminalResizeMessage
+    | TerminalCloseMessage
+    | TerminalSignalMessage
+    | TerminalKillMessage
+    | TerminalListRequest
+)
 
 
 class ControllerConnection:
@@ -70,6 +86,9 @@ class ControllerConnection:
     async def send_terminal_closed(self, message: TerminalClosedMessage) -> None:
         await self._send(message.model_dump())
 
+    async def send_terminal_list_response(self, message: TerminalListResponse) -> None:
+        await self._send(message.model_dump())
+
     async def listen(
         self,
         on_task: Callable[[TaskMessage], Awaitable[None]],
@@ -91,6 +110,12 @@ class ControllerConnection:
                     await on_terminal_message(TerminalResizeMessage(**data))
                 elif on_terminal_message is not None and message_type == 'terminal_close':
                     await on_terminal_message(TerminalCloseMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_signal':
+                    await on_terminal_message(TerminalSignalMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_kill':
+                    await on_terminal_message(TerminalKillMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_list':
+                    await on_terminal_message(TerminalListRequest(**data))
         except ConnectionClosed:
             return
 
@@ -103,7 +128,10 @@ class ControllerConnection:
         if self.websocket is None:
             raise RuntimeError('connection not established')
         async with self._send_lock:
-            await self.websocket.send(json.dumps(payload))
+            try:
+                await self.websocket.send(json.dumps(payload))
+            except ConnectionClosed:
+                LOGGER.debug('skipping outbound message; controller connection is closed')
 
     async def _receive(self) -> dict:
         if self.websocket is None:

{bamboo_coding-0.1.0 → bamboo_coding-0.1.2/src/bamboo_coding}/git_utils.py

@@ -14,7 +14,10 @@ Performance:
 - Diff context is limited to prevent memory issues with large files
 """
 
+import json
 import os
+import shutil
+import subprocess
 import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Any
@@ -2236,3 +2239,145 @@ def rename_workspace_path(path: str, new_path: str) -> Dict[str, Any]:
         'previous_path': str(src),
         'message': 'Path renamed successfully',
     }
+
+
+def search_repository(
+    repo_path: str,
+    query: str,
+    *,
+    case_sensitive: bool = False,
+    whole_word: bool = False,
+    regex: bool = False,
+    max_matches: int = 1000,
+    max_count_per_file: int = 100,
+    timeout_seconds: float = 30.0,
+) -> Dict[str, Any]:
+    """Search the working tree for ``query`` using ripgrep.
+
+    Honors ``.gitignore``, ``.git/info/exclude`` and ``.ignore`` (ripgrep defaults).
+    Returns matches relative to ``repo_path``.
+
+    Raises ``RuntimeError`` with a structured prefix on failure:
+    - ``RIPGREP_NOT_INSTALLED: <hint>`` — ``rg`` binary missing on this machine.
+    - ``INVALID_PATTERN: <stderr line>`` — ripgrep rejected the regex.
+    """
+    if not query:
+        return {'matches': [], 'truncated': False, 'elapsed_ms': 0}
+
+    rg_path = shutil.which('rg')
+    if rg_path is None:
+        raise RuntimeError(
+            'RIPGREP_NOT_INSTALLED: ripgrep (rg) is not installed on the client machine. '
+            'Install it (e.g. `apt install ripgrep` or `brew install ripgrep`) and retry.'
+        )
+
+    normalized_repo = _normalize_path(repo_path)
+    if not Path(normalized_repo).is_dir():
+        raise FileNotFoundError(f'Repository path not found: {repo_path}')
+
+    argv: List[str] = [
+        rg_path,
+        '--json',
+        '--hidden',
+        '--max-filesize=1M',
+        '--crlf',
+        f'--max-count={int(max_count_per_file)}',
+    ]
+    if not regex:
+        argv.append('-F')  # fixed string
+    if not case_sensitive:
+        argv.append('-i')
+    if whole_word:
+        argv.append('-w')
+    argv.append('--')
+    argv.append(query)
+    argv.append(str(normalized_repo))
+
+    start = time.monotonic()
+    try:
+        proc = subprocess.run(
+            argv,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+    except subprocess.TimeoutExpired:
+        elapsed_ms = int((time.monotonic() - start) * 1000)
+        return {'matches': [], 'truncated': True, 'elapsed_ms': elapsed_ms}
+
+    elapsed_ms = int((time.monotonic() - start) * 1000)
+
+    # ripgrep exit codes: 0 = matches, 1 = no matches, 2 = error.
+    if proc.returncode == 2:
+        stderr = (proc.stderr or '').strip().splitlines()
+        first = stderr[0] if stderr else 'ripgrep failed'
+        raise RuntimeError(f'INVALID_PATTERN: {first}')
+
+    matches: List[Dict[str, Any]] = []
+    truncated = False
+    repo_root = str(Path(normalized_repo).resolve())
+
+    for raw_line in (proc.stdout or '').splitlines():
+        if not raw_line:
+            continue
+        try:
+            event = json.loads(raw_line)
+        except json.JSONDecodeError:
+            continue
+        if event.get('type') != 'match':
+            continue
+        data = event.get('data') or {}
+        path_obj = (data.get('path') or {})
+        file_path = path_obj.get('text')
+        if not file_path:
+            # Binary or non-utf8 path — skip.
+            continue
+        try:
+            rel_path = str(Path(file_path).resolve().relative_to(repo_root))
+        except ValueError:
+            rel_path = file_path
+
+        line_obj = (data.get('lines') or {})
+        preview_text = line_obj.get('text', '')
+        if preview_text.endswith('\n'):
+            preview_text = preview_text[:-1]
+        if preview_text.endswith('\r'):
+            preview_text = preview_text[:-1]
+        # Cap preview length to keep payloads small.
+        if len(preview_text) > 500:
+            preview_text = preview_text[:500] + '…'
+
+        line_number = int(data.get('line_number') or 0)
+        submatches = data.get('submatches') or []
+
+        if not submatches:
+            continue
+
+        for submatch in submatches:
+            start_off = int(submatch.get('start') or 0)
+            end_off = int(submatch.get('end') or start_off)
+            # Clamp to preview length (we may have truncated above).
+            if start_off > len(preview_text):
+                start_off = len(preview_text)
+            if end_off > len(preview_text):
+                end_off = len(preview_text)
+            matches.append({
+                'file': rel_path,
+                'line': line_number,
+                'col': start_off + 1,
+                'preview': preview_text,
+                'match_start': start_off,
+                'match_end': end_off,
+            })
+            if len(matches) >= max_matches:
+                truncated = True
+                break
+        if truncated:
+            break
+
+    return {
+        'matches': matches,
+        'truncated': truncated,
+        'elapsed_ms': elapsed_ms,
+    }