bamboo-coding 0.1.0__py3-none-any.whl

bamboo_coding/client/capabilities/repo.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+import git_utils
+from bamboo_coding.shared.protocol import TaskMessage
+
+
+def _allowed_roots(repositories: dict[str, str] | list[str] | tuple[str, ...]) -> list[str]:
+    if isinstance(repositories, dict):
+        values = list(repositories.values()) or list(repositories.keys())
+    else:
+        values = list(repositories)
+    return [str(Path(item).expanduser().resolve()) for item in values]
+
+
+def _resolve_allowed_path(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> str:
+    return _ensure_allowed_path(task.path, repositories)
+
+
+def _ensure_allowed_path(raw_path: str, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> str:
+    target = str(Path(raw_path).expanduser().resolve())
+    for root in _allowed_roots(repositories):
+        try:
+            Path(target).relative_to(root)
+            return target
+        except ValueError:
+            continue
+    raise PermissionError(f"Path outside allowed roots: {raw_path}")
+
+
+def _resolve_repo_root(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> str:
+    allowed_path = _resolve_allowed_path(task, repositories)
+    return git_utils.resolve_git_repository_path(allowed_path)
+
+
+def execute_task(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> dict:
+    handler = _HANDLERS.get((task.capability, task.action))
+    if handler is None:
+        raise KeyError(f"Unsupported task: {task.capability}/{task.action}")
+    git_utils.clear_cache()
+    return handler(task, repositories)
+
+
+def _fs_tree(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    include_nested = bool(task.params.get("all", False))
+    if git_utils.is_git_repository_path(path):
+        repo_path = git_utils.resolve_git_repository_path(path)
+        return git_utils.get_file_tree(repo_path, changed_only=not include_nested)
+    return git_utils.get_workspace_tree(path, include_nested=include_nested)
+
+
+def _fs_browse(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.browse_workspace(path)
+
+
+def _fs_read(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.read_workspace_file(path)
+
+
+def _fs_read_raw(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    max_size = int(task.params.get("max_size_bytes") or task.params.get("max_size") or 0)
+    kwargs = {"max_size_bytes": max_size} if max_size > 0 else {}
+    return git_utils.read_workspace_file_bytes(path, **kwargs)
+
+
+def _fs_write(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.write_workspace_file(path, task.params["content"], task.params.get("encoding", "utf-8"))
+
+
+def _fs_mkdir(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.create_workspace_folder(path, bool(task.params.get("exist_ok", True)))
+
+
+def _fs_delete(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    for root in _allowed_roots(repositories):
+        if path == root:
+            raise PermissionError(f"Refusing to delete workspace root: {path}")
+    return git_utils.delete_workspace_path(path, bool(task.params.get("recursive", False)))
+
+
+def _fs_rename(task: TaskMessage, repositories) -> dict:
+    src = _resolve_allowed_path(task, repositories)
+    raw_destination = task.params.get("to") or task.params.get("new_path")
+    if not raw_destination:
+        raise ValueError("Missing destination path (params.to)")
+    dst = _ensure_allowed_path(str(raw_destination), repositories)
+    for root in _allowed_roots(repositories):
+        if src == root:
+            raise PermissionError(f"Refusing to rename workspace root: {src}")
+    return git_utils.rename_workspace_path(src, dst)
+
+
+def _tree(task: TaskMessage, repositories) -> dict:
+    show_all = bool(task.params.get("all", False))
+    return git_utils.get_file_tree(_resolve_repo_root(task, repositories), changed_only=not show_all)
+
+
+def _browse(task: TaskMessage, repositories) -> dict:
+    return git_utils.browse_directory(_resolve_repo_root(task, repositories), task.params.get("path", "/"))
+
+
+def _diff(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_file_diff(
+        _resolve_repo_root(task, repositories),
+        task.params["file"],
+        bool(task.params.get("staged", False)),
+        int(task.params.get("context", 3)),
+    )
+
+
+def _status(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_repo_status(_resolve_repo_root(task, repositories))
+
+
+def _commits(task: TaskMessage, repositories) -> dict:
+    limit = int(task.params.get("limit", 50))
+    offset = int(task.params.get("offset", 0))
+    repo_path = _resolve_repo_root(task, repositories)
+    return {
+        "commits": git_utils.get_commit_history(repo_path, limit=limit, offset=offset),
+        "limit": limit,
+        "offset": offset,
+    }
+
+
+def _commit_details(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_commit_details(_resolve_repo_root(task, repositories), task.params["commit_hash"])
+
+
+def _read_file(task: TaskMessage, repositories) -> dict:
+    return git_utils.read_file_content(_resolve_repo_root(task, repositories), task.params["file_path"])
+
+
+def _write_file(task: TaskMessage, repositories) -> dict:
+    return git_utils.write_file_content(
+        _resolve_repo_root(task, repositories),
+        task.params["file_path"],
+        task.params["content"],
+        task.params.get("encoding", "utf-8"),
+    )
+
+
+def _stage(task: TaskMessage, repositories) -> dict:
+    repo_path = _resolve_repo_root(task, repositories)
+    if task.params.get("stage_all"):
+        return git_utils.stage_all_files(repo_path)
+    return git_utils.stage_file(repo_path, task.params["file_path"])
+
+
+def _unstage(task: TaskMessage, repositories) -> dict:
+    return git_utils.unstage_file(_resolve_repo_root(task, repositories), task.params["file_path"])
+
+
+def _list_branches(task: TaskMessage, repositories) -> dict:
+    return git_utils.list_branches(_resolve_repo_root(task, repositories))
+
+
+def _create_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.create_branch(_resolve_repo_root(task, repositories), task.params["name"], task.params.get("start_point"))
+
+
+def _checkout_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.switch_branch(_resolve_repo_root(task, repositories), task.params["name"])
+
+
+def _delete_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.delete_branch(_resolve_repo_root(task, repositories), task.params["name"], bool(task.params.get("force", False)))
+
+
+def _merge_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.merge_branch(_resolve_repo_root(task, repositories), task.params["source"], task.params.get("message"))
+
+
+def _create_commit(task: TaskMessage, repositories) -> dict:
+    return git_utils.create_commit(
+        _resolve_repo_root(task, repositories),
+        task.params["message"],
+        task.params.get("author_name"),
+        task.params.get("author_email"),
+    )
+
+
+def _list_remotes(task: TaskMessage, repositories) -> dict:
+    return git_utils.list_remotes(_resolve_repo_root(task, repositories))
+
+
+def _add_remote(task: TaskMessage, repositories) -> dict:
+    return git_utils.add_remote(
+        _resolve_repo_root(task, repositories),
+        task.params["name"],
+        task.params["url"],
+    )
+
+
+def _remove_remote(task: TaskMessage, repositories) -> dict:
+    return git_utils.remove_remote(
+        _resolve_repo_root(task, repositories),
+        task.params["name"],
+    )
+
+
+def _push_remote(task: TaskMessage, repositories) -> dict:
+    return git_utils.push_to_remote(
+        _resolve_repo_root(task, repositories),
+        task.params["remote"],
+        task.params.get("local_branch"),
+        task.params.get("remote_branch"),
+        bool(task.params.get("set_upstream", False)),
+        bool(task.params.get("force", False)),
+    )
+
+
+def _pull_remote(task: TaskMessage, repositories) -> dict:
+    return git_utils.pull_from_remote(
+        _resolve_repo_root(task, repositories),
+        task.params["remote"],
+        task.params.get("local_branch"),
+        task.params.get("remote_branch"),
+        bool(task.params.get("rebase", False)),
+    )
+
+
+_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,
+    ("fs.file.read", "get"): _fs_read,
+    ("fs.file.read_raw", "get"): _fs_read_raw,
+    ("fs.file.write", "put"): _fs_write,
+    ("fs.folder.create", "post"): _fs_mkdir,
+    ("fs.path.delete", "delete"): _fs_delete,
+    ("fs.path.rename", "put"): _fs_rename,
+    ("repo.tree", "get"): _tree,
+    ("repo.browse", "get"): _browse,
+    ("repo.diff", "get"): _diff,
+    ("repo.status", "get"): _status,
+    ("repo.commits", "list"): _commits,
+    ("repo.commit_details", "get"): _commit_details,
+    ("repo.file.read", "get"): _read_file,
+    ("repo.file.write", "put"): _write_file,
+    ("repo.stage", "post"): _stage,
+    ("repo.unstage", "post"): _unstage,
+    ("repo.branches.list", "get"): _list_branches,
+    ("repo.branches.create", "post"): _create_branch,
+    ("repo.branches.checkout", "put"): _checkout_branch,
+    ("repo.branches.delete", "delete"): _delete_branch,
+    ("repo.branches.merge", "post"): _merge_branch,
+    ("repo.commit.create", "post"): _create_commit,
+    ("repo.remotes.list", "get"): _list_remotes,
+    ("repo.remotes.add", "post"): _add_remote,
+    ("repo.remotes.remove", "delete"): _remove_remote,
+    ("repo.remotes.push", "post"): _push_remote,
+    ("repo.remotes.pull", "post"): _pull_remote,
+    ("git.remotes.list", "get"): _list_remotes,
+    ("git.remotes.add", "post"): _add_remote,
+    ("git.remotes.remove", "delete"): _remove_remote,
+    ("git.remotes.push", "post"): _push_remote,
+    ("git.remotes.pull", "post"): _pull_remote,
+    ("git.status", "get"): _status,
+    ("git.diff", "get"): _diff,
+    ("git.commits", "list"): _commits,
+    ("git.commit_details", "get"): _commit_details,
+    ("git.stage", "post"): _stage,
+    ("git.unstage", "post"): _unstage,
+    ("git.branches.list", "get"): _list_branches,
+    ("git.branches.create", "post"): _create_branch,
+    ("git.branches.checkout", "put"): _checkout_branch,
+    ("git.branches.delete", "delete"): _delete_branch,
+    ("git.branches.merge", "post"): _merge_branch,
+    ("git.commit.create", "post"): _create_commit,
+}

bamboo_coding/client/config.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import tomllib
+from dataclasses import dataclass, field
+from importlib import metadata
+from pathlib import Path
+
+
+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"
+
+
+@dataclass(frozen=True)
+class RepositoryConfig:
+    repo_id: str
+    name: str
+    path: str
+
+
+@dataclass(frozen=True)
+class AgentConfig:
+    controller_url: str
+    client_id: str
+    hostname: str
+    version: str
+    token: str
+    token_path: Path
+    journal_path: Path
+    config_path: Path = field(default_factory=Path)
+    max_concurrent_tasks: int = 1
+    allowed_roots: tuple[str, ...] = field(default_factory=tuple)
+    repositories: tuple[RepositoryConfig, ...] = field(default_factory=tuple)
+
+
+def _first_env(*names: str) -> str | None:
+    for name in names:
+        value = os.getenv(name)
+        if value:
+            return value
+    return None
+
+
+def _default_version() -> str:
+    try:
+        return metadata.version("bamboo-coding")
+    except metadata.PackageNotFoundError:
+        return "0.1.0"
+
+
+def _normalize_root(path_value: str) -> str:
+    return str(Path(path_value).expanduser().resolve())
+
+
+def _resolve_path(value: str | None, *, default: Path, base_dir: Path) -> Path:
+    if not value:
+        return default
+    path = Path(value).expanduser()
+    if not path.is_absolute():
+        path = base_dir / path
+    return path.resolve()
+
+
+def _load_toml(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    with path.open("rb") as handle:
+        data = tomllib.load(handle)
+    return data if isinstance(data, dict) else {}
+
+
+def _coerce_allowed_roots(value: object) -> tuple[str, ...]:
+    if isinstance(value, str):
+        items = [item for item in value.split(os.pathsep) if item.strip()]
+    elif isinstance(value, (list, tuple)):
+        items = [str(item) for item in value if str(item).strip()]
+    else:
+        items = []
+    return tuple(_normalize_root(item) for item in items)
+
+
+def _load_stored_token(token_path: Path) -> str:
+    if not token_path.exists():
+        return ""
+    try:
+        payload = json.loads(token_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return ""
+    token = payload.get("token")
+    return token if isinstance(token, str) else ""
+
+
+def _persist_token(token_path: Path, token: str) -> None:
+    token_path.parent.mkdir(parents=True, exist_ok=True)
+    token_path.write_text(json.dumps({"token": token}), encoding="utf-8")
+
+
+def _load_legacy_token(default_token_path: Path) -> str:
+    legacy_path = Path.cwd() / ".agent" / "token.json"
+    token = _load_stored_token(legacy_path)
+    if token and not default_token_path.exists():
+        _persist_token(default_token_path, token)
+    return token
+
+
+def load_config() -> AgentConfig:
+    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"),
+        default=config_home / DEFAULT_CONFIG_FILENAME,
+        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 {}
+
+    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
+
+    controller_url = _first_env("BAMBOO_CODING_CONTROLLER_URL", "CONTROLLER_URL") or str(
+        client_config.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
+    )
+    hostname = _first_env("BAMBOO_CODING_HOSTNAME", "AGENT_HOSTNAME") or str(
+        client_config.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())
+    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")
+    )
+    max_concurrent_tasks = int(
+        _first_env("BAMBOO_CODING_MAX_CONCURRENT_TASKS", "AGENT_MAX_CONCURRENT_TASKS")
+        or client_config.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",
+        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",
+        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"):
+        token = _load_legacy_token(token_path)
+
+    repositories = tuple(
+        RepositoryConfig(
+            repo_id=root,
+            name=Path(root).name or root,
+            path=root,
+        )
+        for root in allowed_roots
+    )
+    return AgentConfig(
+        controller_url=controller_url,
+        client_id=client_id,
+        hostname=hostname,
+        version=version,
+        token=token,
+        token_path=token_path,
+        journal_path=journal_path,
+        config_path=config_path,
+        max_concurrent_tasks=max_concurrent_tasks,
+        allowed_roots=allowed_roots,
+        repositories=repositories,
+    )

bamboo_coding/client/controller_client.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Awaitable, Callable
+
+from websockets import connect
+from websockets.exceptions import ConnectionClosed
+
+from bamboo_coding.shared.protocol import (
+    AgentRegisterMessage,
+    ClientStatusMessage,
+    TaskEventMessage,
+    TaskMessage,
+    TaskQueryResultMessage,
+    TaskResultMessage,
+    TerminalCloseMessage,
+    TerminalInputMessage,
+    TerminalHeartbeatMessage,
+    TerminalOpenMessage,
+    TerminalOutputMessage,
+    TerminalResizeMessage,
+    TerminalStatusMessage,
+    TerminalClosedMessage,
+)
+
+
+TerminalControlMessage = TerminalOpenMessage | TerminalInputMessage | TerminalResizeMessage | TerminalCloseMessage
+
+
+class ControllerConnection:
+    def __init__(self, controller_url: str, token: str = ''):
+        self.controller_url = controller_url
+        self.token = token
+        self.websocket = None
+        self._send_lock = asyncio.Lock()
+
+    async def connect(self):
+        headers = {}
+        if self.token:
+            headers['Authorization'] = f'Bearer {self.token}'
+        self.websocket = await connect(self.controller_url, extra_headers=headers or None, ping_interval=20, ping_timeout=20)
+        return self.websocket
+
+    async def send_register(self, message: AgentRegisterMessage) -> dict:
+        await self._send(message.model_dump())
+        return await self._receive()
+
+    async def send_status(self, message: ClientStatusMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_event(self, message: TaskEventMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_result(self, message: TaskResultMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_query_result(self, message: TaskQueryResultMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_terminal_status(self, message: TerminalStatusMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_terminal_output(self, message: TerminalOutputMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_terminal_heartbeat(self, message: TerminalHeartbeatMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_terminal_closed(self, message: TerminalClosedMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def listen(
+        self,
+        on_task: Callable[[TaskMessage], Awaitable[None]],
+        on_terminal_message: Callable[[TerminalControlMessage], Awaitable[None]] | None = None,
+    ) -> None:
+        if self.websocket is None:
+            raise RuntimeError('connection not established')
+        try:
+            async for raw in self.websocket:
+                data = json.loads(raw)
+                message_type = data.get('type')
+                if message_type == 'task':
+                    await on_task(TaskMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_open':
+                    await on_terminal_message(TerminalOpenMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_input':
+                    await on_terminal_message(TerminalInputMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_resize':
+                    await on_terminal_message(TerminalResizeMessage(**data))
+                elif on_terminal_message is not None and message_type == 'terminal_close':
+                    await on_terminal_message(TerminalCloseMessage(**data))
+        except ConnectionClosed:
+            return
+
+    async def close(self) -> None:
+        if self.websocket is not None:
+            await self.websocket.close()
+            self.websocket = None
+
+    async def _send(self, payload: dict) -> None:
+        if self.websocket is None:
+            raise RuntimeError('connection not established')
+        async with self._send_lock:
+            await self.websocket.send(json.dumps(payload))
+
+    async def _receive(self) -> dict:
+        if self.websocket is None:
+            raise RuntimeError('connection not established')
+        raw = await self.websocket.recv()
+        return json.loads(raw)

bamboo_coding/client/journal.py

@@ -0,0 +1 @@
+from agent.bamboo_git_agent.journal import *  # noqa: F401,F403