bamboo-coding 0.1.0__py3-none-any.whl

bamboo_coding/client/terminal_runtime.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import shlex
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+from bamboo_ssh import TerminalSession, stream_terminal_output
+
+from bamboo_coding.shared.protocol import (
+    TerminalClosedMessage,
+    TerminalHeartbeatMessage,
+    TerminalInputMessage,
+    TerminalOpenMessage,
+    TerminalOutputMessage,
+    TerminalStatusMessage,
+)
+
+
+MessageCallback = Callable[[Any], Awaitable[None] | None]
+DEFAULT_OUTPUT_FLUSH_INTERVAL = 0.05
+DEFAULT_HEARTBEAT_INTERVAL = 10.0
+MAX_PENDING_OUTPUT_CHARS = 262144
+TRUNCATED_OUTPUT_NOTICE = "\r\n[terminal output truncated while relay caught up]\r\n"
+
+
+def build_initial_cwd_command(path: str) -> str:
+    if not path:
+        return ''
+    target = Path(path).expanduser()
+    resolved = target.resolve(strict=False)
+    working_dir = resolved if resolved.is_dir() else resolved.parent
+    return f"cd {shlex.quote(str(working_dir))}\n"
+
+
+@dataclass
+class ActiveTerminalSession:
+    terminal_id: str
+    session: TerminalSession
+    reader_task: asyncio.Task | None = None
+    output_task: asyncio.Task | None = None
+    heartbeat_task: asyncio.Task | None = None
+    output_event: asyncio.Event = field(default_factory=asyncio.Event)
+    pending_output: list[str] = field(default_factory=list)
+    pending_output_chars: int = 0
+    output_truncated: bool = False
+
+
+class ClientTerminalRuntime:
+    def __init__(
+        self,
+        *,
+        send_status: MessageCallback,
+        send_output: MessageCallback,
+        send_closed: MessageCallback,
+        send_heartbeat: MessageCallback | None = None,
+        output_flush_interval: float = DEFAULT_OUTPUT_FLUSH_INTERVAL,
+        heartbeat_interval: float = DEFAULT_HEARTBEAT_INTERVAL,
+        max_pending_output_chars: int = MAX_PENDING_OUTPUT_CHARS,
+    ):
+        self.send_status = send_status
+        self.send_output = send_output
+        self.send_closed = send_closed
+        self.send_heartbeat = send_heartbeat or (lambda _message: None)
+        self.output_flush_interval = output_flush_interval
+        self.heartbeat_interval = heartbeat_interval
+        self.max_pending_output_chars = max_pending_output_chars
+        self.sessions: dict[str, ActiveTerminalSession] = {}
+
+    async def open_terminal(self, message: TerminalOpenMessage) -> None:
+        await self.close_terminal(message.terminal_id, reason='replaced', emit_closed=False)
+        await self._emit(
+            self.send_status,
+            TerminalStatusMessage(terminal_id=message.terminal_id, status='starting'),
+        )
+        session = TerminalSession.start(cols=message.cols, rows=message.rows, command=build_initial_cwd_command(message.path))
+        active = ActiveTerminalSession(
+            terminal_id=message.terminal_id,
+            session=session,
+        )
+        self.sessions[message.terminal_id] = active
+        active.output_task = asyncio.create_task(
+            self._flush_output_loop(message.terminal_id),
+            name=f'terminal-output:{message.terminal_id}',
+        )
+        active.heartbeat_task = asyncio.create_task(
+            self._heartbeat_loop(message.terminal_id),
+            name=f'terminal-heartbeat:{message.terminal_id}',
+        )
+        active.reader_task = asyncio.create_task(
+            self._stream_terminal(message.terminal_id, session),
+            name=f'terminal:{message.terminal_id}',
+        )
+
+    async def input_terminal(self, message: TerminalInputMessage) -> None:
+        active = self.sessions.get(message.terminal_id)
+        if active is None:
+            return
+        try:
+            active.session.write(message.data)
+        except Exception as exc:
+            await self._emit(
+                self.send_status,
+                TerminalStatusMessage(terminal_id=message.terminal_id, status='error', message=str(exc)),
+            )
+            await self.close_terminal(message.terminal_id, reason='write_failed')
+
+    async def resize_terminal(self, terminal_id: str, *, cols: int, rows: int) -> None:
+        active = self.sessions.get(terminal_id)
+        if active is None:
+            return
+        try:
+            active.session.resize(cols, rows)
+        except Exception as exc:
+            await self._emit(
+                self.send_status,
+                TerminalStatusMessage(terminal_id=terminal_id, status='error', message=str(exc)),
+            )
+            await self.close_terminal(terminal_id, reason='resize_failed')
+
+    async def close_terminal(
+        self,
+        terminal_id: str,
+        *,
+        reason: str = 'closed',
+        emit_closed: bool = True,
+        exit_code: int | None = None,
+    ) -> None:
+        active = self.sessions.pop(terminal_id, None)
+        if active is None:
+            return
+        active.session.close()
+        current_task = asyncio.current_task()
+        for task in (active.reader_task, active.output_task, active.heartbeat_task):
+            if task is None or task is current_task:
+                continue
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+        await self._flush_pending_output(active)
+        if emit_closed:
+            if exit_code is None:
+                exit_code = getattr(getattr(active.session, 'process', None), 'returncode', None)
+            await self._emit(
+                self.send_closed,
+                TerminalClosedMessage(terminal_id=terminal_id, reason=reason, exit_code=exit_code),
+            )
+
+    async def close_all(self, reason: str = 'shutdown') -> None:
+        for terminal_id in list(self.sessions):
+            await self.close_terminal(terminal_id, reason=reason)
+
+    async def _stream_terminal(self, terminal_id: str, session: TerminalSession) -> None:
+        async def send_json(payload: dict) -> None:
+            message_type = payload.get('type')
+            if message_type == 'ready':
+                await self._emit(self.send_status, TerminalStatusMessage(terminal_id=terminal_id, status='ready'))
+            elif message_type == 'cmd':
+                self._queue_output(terminal_id, str(payload.get('data') or ''))
+
+        try:
+            await stream_terminal_output(session, send_json)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            if terminal_id in self.sessions:
+                await self._emit(
+                    self.send_status,
+                    TerminalStatusMessage(terminal_id=terminal_id, status='error', message=str(exc)),
+                )
+        finally:
+            active = self.sessions.get(terminal_id)
+            if active is not None:
+                exit_code = getattr(getattr(active.session, 'process', None), 'returncode', None)
+                await self.close_terminal(terminal_id, reason='session_ended', exit_code=exit_code)
+
+    def _queue_output(self, terminal_id: str, data: str) -> None:
+        if not data:
+            return
+        active = self.sessions.get(terminal_id)
+        if active is None:
+            return
+        active.pending_output.append(data)
+        active.pending_output_chars += len(data)
+        while active.pending_output_chars > self.max_pending_output_chars and active.pending_output:
+            removed = active.pending_output.pop(0)
+            active.pending_output_chars -= len(removed)
+            active.output_truncated = True
+        active.output_event.set()
+
+    async def _flush_output_loop(self, terminal_id: str) -> None:
+        try:
+            while True:
+                active = self.sessions.get(terminal_id)
+                if active is None:
+                    return
+                await active.output_event.wait()
+                await asyncio.sleep(self.output_flush_interval)
+                active = self.sessions.get(terminal_id)
+                if active is None:
+                    return
+                await self._flush_pending_output(active)
+        except asyncio.CancelledError:
+            raise
+
+    async def _flush_pending_output(self, active: ActiveTerminalSession) -> None:
+        if not active.pending_output and not active.output_truncated:
+            active.output_event.clear()
+            return
+        payload = ''.join(active.pending_output)
+        active.pending_output.clear()
+        active.pending_output_chars = 0
+        if active.output_truncated:
+            payload = f'{TRUNCATED_OUTPUT_NOTICE}{payload}'
+            active.output_truncated = False
+        active.output_event.clear()
+        if payload:
+            await self._emit(
+                self.send_output,
+                TerminalOutputMessage(terminal_id=active.terminal_id, data=payload),
+            )
+
+    async def _heartbeat_loop(self, terminal_id: str) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self.heartbeat_interval)
+                active = self.sessions.get(terminal_id)
+                if active is None:
+                    return
+                process = getattr(active.session, 'process', None)
+                poll = getattr(process, 'poll', None)
+                exit_code = poll() if callable(poll) else getattr(process, 'returncode', None)
+                process_alive = exit_code is None
+                await self._emit(
+                    self.send_heartbeat,
+                    TerminalHeartbeatMessage(terminal_id=terminal_id, process_alive=process_alive),
+                )
+                if not process_alive:
+                    await self.close_terminal(terminal_id, reason='session_ended', exit_code=exit_code)
+                    return
+        except asyncio.CancelledError:
+            raise
+
+    async def _emit(self, callback: MessageCallback, message: Any) -> None:
+        result = callback(message)
+        if inspect.isawaitable(result):
+            await result

bamboo_coding/server/__init__.py

@@ -0,0 +1,3 @@
+from .main import app, create_app, main
+
+__all__ = ["app", "create_app", "main"]

bamboo_coding/server/core/__init__.py

@@ -0,0 +1 @@
+"""Server configuration helpers."""

bamboo_coding/server/core/config.py

@@ -0,0 +1 @@
+from controller.app.core.config import *  # noqa: F401,F403

bamboo_coding/server/main.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+import uvicorn
+from dotenv import load_dotenv
+
+from controller.app.main import app, create_app
+
+
+load_dotenv()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Bamboo Coding")
+    parser.add_argument("--dev", action="store_true", help="Run in development mode with auto-reload")
+    parser.add_argument("--port", type=int, help="Port to run on")
+    parser.add_argument("--host", help="Host to bind to")
+    args = parser.parse_args()
+
+    host = args.host or os.getenv("HOST", "0.0.0.0")
+    port = args.port or int(os.getenv("PORT", 8100))
+    reload_enabled = bool(args.dev)
+
+    uvicorn.run(
+        "bamboo_coding.server.main:app",
+        host=host,
+        port=port,
+        reload=reload_enabled,
+        factory=False,
+    )
+
+
+__all__ = ["app", "create_app", "main"]
+
+
+if __name__ == "__main__":
+    main()

bamboo_coding/shared/__init__.py

@@ -0,0 +1,39 @@
+from .protocol import (
+    AgentRegisterMessage,
+    CapabilityDescriptor,
+    ClientInfo,
+    ClientStatusMessage,
+    PublicRepositorySummary,
+    PublicRootSummary,
+    RepositoryDescriptor,
+    RootDescriptor,
+    RuntimeHealth,
+    TaskMessage,
+    TerminalCloseMessage,
+    TerminalClosedMessage,
+    TerminalInputMessage,
+    TerminalOpenMessage,
+    TerminalOutputMessage,
+    TerminalResizeMessage,
+    TerminalStatusMessage,
+)
+
+__all__ = [
+    "AgentRegisterMessage",
+    "CapabilityDescriptor",
+    "ClientInfo",
+    "ClientStatusMessage",
+    "PublicRepositorySummary",
+    "PublicRootSummary",
+    "RepositoryDescriptor",
+    "RootDescriptor",
+    "RuntimeHealth",
+    "TaskMessage",
+    "TerminalCloseMessage",
+    "TerminalClosedMessage",
+    "TerminalInputMessage",
+    "TerminalOpenMessage",
+    "TerminalOutputMessage",
+    "TerminalResizeMessage",
+    "TerminalStatusMessage",
+]

bamboo_coding/shared/protocol.py

@@ -0,0 +1 @@
+from shared.protocol import *  # noqa: F401,F403

bamboo_coding-0.1.0.dist-info/METADATA

@@ -0,0 +1,284 @@
+Metadata-Version: 2.4
+Name: bamboo-coding
+Version: 0.1.0
+Summary: Bamboo Coding controller and client
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi==0.115.0
+Requires-Dist: uvicorn==0.30.6
+Requires-Dist: gitpython==3.1.40
+Requires-Dist: python-dotenv==1.0.0
+Requires-Dist: websockets==13.1
+Requires-Dist: httpx==0.27.2
+Requires-Dist: bamboo-ssh
+
+# Bamboo Coding
+
+Bamboo Coding is a FastAPI-based workspace and Git review system with an outbound Python client and a browser UI.
+
+## Architecture
+
+- `bamboo_coding/server/`: packaged server entrypoint and public app surface
+- `bamboo_coding/client/`: packaged outbound client runtime
+- `controller/app/`: controller internals used by the packaged server entrypoint
+- `shared/`: legacy shared protocol implementation backing the new namespace
+- `static/`: browser UI assets
+
+The controller never reads arbitrary local paths itself. Clients connect outward, advertise allowed roots, wait for approval, and then handle tasks for paths inside those roots.
+
+## Features
+
+- Web approval for pending clients
+- Client-first workspace selection in the UI
+- Direct folder browsing, including non-Git folders
+- Automatic Git mode when the selected path is inside a repository
+- Changed-files-first tree, diff viewer, commit history, branches, stage/unstage, and commit
+- Durable client token storage and task journal
+- Multi-terminal browser dialogs bound to the selected client and path
+
+## Requirements
+
+- Python 3.12+
+- Git 2.x+
+
+## Install
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+pip install -e .
+```
+
+## Client Config
+
+The client reads `~/.bamboo-coding/bamboo-coding.toml` by default.
+
+Quick start:
+
+```bash
+bamboo-coding setup
+bamboo-coding run
+```
+
+`setup` creates the config file if it is missing. By default it uses the current working directory as the first allowed root. You can override the generated values:
+
+```bash
+bamboo-coding setup --root /work/project-a --root /work/project-b --client-id worker-1 --hostname devbox
+```
+
+Example generated config:
+
+```toml
+[client]
+controller_url = "ws://127.0.0.1:8100/ws/agents"
+client_id = "worker-1"
+hostname = "devbox"
+allowed_roots = ["/work/project-a", "/work/project-b"]
+max_concurrent_tasks = 1
+
+[storage]
+token_path = "~/.bamboo-coding/token.json"
+journal_path = "~/.bamboo-coding/journal.db"
+```
+
+Environment variables still override TOML values. Existing `AGENT_*` overrides remain supported during the transition.
+
+## Makefile Commands
+
+The repository now includes a root `Makefile` as the quick command hub.
+
+Common targets:
+
+```bash
+make help              # list available commands
+make dev               # run the server locally
+make start             # start the server with docker compose
+make stop              # stop the docker compose stack
+make restart           # restart the docker compose stack
+make logs              # follow server logs
+make ps                # show compose service state
+make test              # run the full pytest suite
+make client-install    # install editable package plus build/upload tooling
+make client-clean      # remove build artifacts and Python cache files
+make client-build      # build wheel and sdist into dist/
+make client-reinstall  # clean and reinstall the editable package
+make client-deploy     # publish dist/* to real PyPI
+```
+
+`client-deploy` publishes to the real PyPI index. It prompts for a PyPI deploy
+token when one is missing:
+
+```bash
+make client-deploy
+```
+
+You can also provide the token through the environment for non-interactive runs:
+
+```bash
+export PYPI_TOKEN=<pypi-token>
+make client-deploy
+```
+
+The Makefile maps `PYPI_TOKEN` to Twine's token auth internally by setting
+`TWINE_USERNAME=__token__` and `TWINE_PASSWORD=<pypi-token>`.
+
+## Docker Folder
+
+The server Docker assets live under `docker/`:
+
+```text
+docker/
+  compose.server.yml
+  server.Dockerfile
+```
+
+## Run Locally
+
+### 1. Start the server
+
+```bash
+bamboo-coding-server --dev --host 127.0.0.1 --port 8100
+```
+
+The legacy launcher also still works:
+
+```bash
+.venv/bin/python app.py --dev --host 127.0.0.1 --port 8100
+```
+
+### 2. Setup and run a client
+
+First write the default config:
+
+```bash
+bamboo-coding setup
+```
+
+Then start the long-running client:
+
+```bash
+bamboo-coding run
+```
+
+Bare `bamboo-coding` is an alias for `bamboo-coding run`.
+
+For one-off value overrides you can still use environment variables, but `run` still expects a config file to exist:
+
+```bash
+CONTROLLER_URL=ws://127.0.0.1:8100/ws/agents AGENT_CLIENT_ID=worker-1 AGENT_ALLOWED_ROOTS=/work/project-a:/work/project-b bamboo-coding run
+```
+
+The module entrypoint is also available:
+
+```bash
+.venv/bin/python -m bamboo_coding.client.main run
+```
+
+### 3. Approve the client in the web UI
+
+Open:
+
+```text
+http://127.0.0.1:8100/
+```
+
+The start page shows:
+
+- approved clients first, with live root counts
+- pending clients with an `Approve` button
+- roots and immediate children only after you pick a specific client
+
+Once approved, the client stores its token under `~/.bamboo-coding/` by default and reconnects automatically on the next start.
+
+### 4. Open terminals from the web UI
+
+After you pick a client and workspace, use the `Terminal` button in the header.
+
+Terminal behavior:
+
+- each terminal attaches to the currently selected client
+- the initial shell directory uses the current selected path
+- you can open multiple terminals in the same page
+- windows can be dragged, resized, and maximized inside the page
+- `Hide` moves a terminal into the bottom-right dock; click the dock item to restore it
+- the header `Layout` control supports `Hidden`, `1`, `1|2`, `1|2|3`, and `2x2` presets
+- applying `Hidden` docks every open terminal without closing the sessions
+- applying a layout restores all open terminals, fills the preset slots by open order, and docks overflow terminals
+- with an active layout, new terminals join the preset only while free slots remain; after that they open as floating windows
+- the main page `Shortcuts` button opens browser-local terminal shortcut settings
+- default terminal shortcuts are `Ctrl+Down` for `Hidden` and `Ctrl+Up` for `2x2`
+- leaving or refreshing the page while any terminal windows remain open triggers the browser unload warning
+
+There is also a standalone terminal page that reuses the same component:
+
+```text
+http://127.0.0.1:8100/terminal?agent_id=<agent-id>&path=/absolute/path
+```
+
+### 5. Open a specific workspace directly
+
+When multiple clients may advertise the same path, include both the client and the path:
+
+```text
+http://127.0.0.1:8100/?agent_id=<agent-id>&path=/absolute/path/inside/an/approved/root
+```
+
+Path-only links still work when the owner is unambiguous:
+
+```text
+http://127.0.0.1:8100/?path=/absolute/path/inside/an/approved/root
+```
+
+If the path is inside a Git repository, Git actions are enabled. If it is only a normal folder, the UI still shows the file tree and editor.
+
+## Public API
+
+### Discovery and approval
+
+- `GET /api/health`
+- `GET /api/agents` (includes live `roots` for connected approved clients)
+- `POST /api/agents/{agent_id}/approve`
+- `GET /api/roots`
+
+### Filesystem
+
+- `GET /api/fs/tree?path=...&agent_id=...`
+- `GET /api/fs/browse?path=...&agent_id=...`
+- `GET /api/fs/file?path=...&agent_id=...`
+- `PUT /api/fs/file?path=...&agent_id=...`
+
+### Git
+
+- `GET /api/git/status?path=...&agent_id=...`
+- `GET /api/git/diff?path=...&file=...&agent_id=...`
+- `GET /api/git/commits?path=...&agent_id=...`
+- `GET /api/git/commit/{commit_hash}?path=...&agent_id=...`
+- `POST /api/git/stage?path=...&agent_id=...`
+- `POST /api/git/unstage?path=...&agent_id=...`
+- `GET /api/git/branches?path=...&agent_id=...`
+- `POST /api/git/branches?path=...&agent_id=...`
+- `PUT /api/git/branches/checkout?path=...&agent_id=...`
+- `DELETE /api/git/branches/{name}?path=...&agent_id=...`
+- `POST /api/git/branches/merge?path=...&agent_id=...`
+- `POST /api/git/commit?path=...&agent_id=...`
+
+### Client transport
+
+- `WS /ws/agents`
+- `WS /ws/terminal?agent_id=...&path=...&terminal_id=...&cols=...&rows=...`
+
+## Testing
+
+```bash
+.venv/bin/python -m pytest -q
+```
+
+## Repository Layout
+
+- `app.py`: legacy server launcher pointing at `bamboo_coding.server.main`
+- `bamboo_coding/server/`: packaged server entrypoint
+- `bamboo_coding/client/`: packaged client runtime
+- `controller/app/`: controller internals
+- `static/`: SPA assets
+- `docker/`: server Docker Compose and Dockerfile assets
+- `tests/`: controller, client, protocol, and Git utility tests

bamboo_coding-0.1.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+git_utils.py,sha256=y1NsxtvsY7gOXjym-sVld6b4Qw5CQ-OdqzlqhBVY9eY,82025
+agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent/bamboo_git_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent/bamboo_git_agent/config.py,sha256=cDzCRi2Tz8H71-cK6gW8f4m6BlqOWT2Du-le0pDcE08,2454
+agent/bamboo_git_agent/controller_client.py,sha256=qPMp-JEoCbSxMR5OH114QQ9ZjIi134jWU47n5ro7M3w,2467
+agent/bamboo_git_agent/journal.py,sha256=xIK4aBYrYwqLddZ3LAX4tuY6ugjUPFxb5TP_Fkrqog8,8504
+agent/bamboo_git_agent/main.py,sha256=svI0KmXWOBtybc7Gk1UviECg4XCEPbFF0MQgUwIx88o,7338
+agent/bamboo_git_agent/protocol.py,sha256=MPSxQVhkw__IIqsqeS-j46OsUHjvWT_WJH4qnE42lcA,445
+agent/bamboo_git_agent/status.py,sha256=QhCgmhDx6sLpsWHD516LGirBJMxDDFFfHjLdg5BHbJk,2532
+agent/bamboo_git_agent/capabilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent/bamboo_git_agent/capabilities/repo.py,sha256=HJrkmcEGgnAZ7uXW2Yky3INno4DG-Vhesa9qO5JPM2w,7271
+api/__init__.py,sha256=UMv3OaonM4UouYy8NRtLWNj5Hh1IE-SEdV0jMTMya10,35
+api/commit.py,sha256=IGS9O5_A22cZ6dBWR0mYqOUgT4HQl3lt2mC5jWiE8po,2343
+api/repository.py,sha256=HiGwG-Bjz_Toy4sUGgKLopkAexYD2QbvinPOgRNowvo,17763
+bamboo_coding/__init__.py,sha256=46h_Uj5gdx8oYtLJDZMgSyA-APe5YE7vLfgyQaCb32o,71
+bamboo_coding/client/__init__.py,sha256=3wip8Z6F-mf1YUXavSPFM1jBu3i3NXU1Yp1ymaHrpq8,125
+bamboo_coding/client/config.py,sha256=3NQ7HzmOy1Y-rjgDAUbyKJ1RCxpOylWR8ZY5boxUFFU,5953
+bamboo_coding/client/controller_client.py,sha256=UvhbOZpszNy8soOkoCevCuSbDDpwjDNzZTdVAVbQ5qo,4262
+bamboo_coding/client/journal.py,sha256=uZJesILPzOYKTJJaJAWN5_e_h3ONp1Nl7EVbYtfhHuA,64
+bamboo_coding/client/main.py,sha256=osxHMu3UJGAvmrJmhS1Jd4yKuggUiqn-iCc3RjvBfXs,17697
+bamboo_coding/client/status.py,sha256=xX2Ofjmuf5B9y7NsdG9djxNoH1DOw_NWr0gjK_GPw6c,2546
+bamboo_coding/client/terminal_runtime.py,sha256=_mWWKOUcizqgwLXYhZAxI_LPW0bzTXcd03b58ZYi6yA,9916
+bamboo_coding/client/capabilities/__init__.py,sha256=B7qxGhwcbKpRuE2jiZDa85BzYRCFyTEGWK_TWfRvFWQ,34
+bamboo_coding/client/capabilities/repo.py,sha256=02FhJGdnT2Jpd9whfKfxzrQvNt9xwty1hm42hwmzLYw,10768
+bamboo_coding/server/__init__.py,sha256=T-PUHHEg8K4GY9IkpxyN4-28eD01KU2W1JfgNqMHT8U,81
+bamboo_coding/server/main.py,sha256=85P-AAzjiGKfSHBtTlMfDYq9-rUTuV0xf7TGBhITSGQ,903
+bamboo_coding/server/core/__init__.py,sha256=Utes-Fcxa2vnzgU3ZCimYF7Y78PrzswLkPpNtQpUHF0,36
+bamboo_coding/server/core/config.py,sha256=RhQF4gYFtfC6k_fm33nKQgwJgE0GZYn-OV81u9oOJHY,60
+bamboo_coding/shared/__init__.py,sha256=2hU3m0yWwYevIoOEJqkoumqVGW4CGrQIYHE_q1ftpbk,899
+bamboo_coding/shared/protocol.py,sha256=qnbT6fMKp-d7-e_sFq5QPfG0gPTrxuAAuczLFZuTenc,49
+controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/main.py,sha256=2TAQewTF65lBxKHUimmBT6mnIE0ZRdl9kuHkVUM6fGM,2841
+controller/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/api/agents/__init__.py,sha256=-GnMriR-KQnvpEZYjyDNFEtMHV5yXpfJmBQ4bAXWn-w,45
+controller/app/api/agents/ws.py,sha256=VQN_1D5QezbjIaMXiCXv1UxoCeEHTz3QIKuCfhtV4hA,5411
+controller/app/api/public/__init__.py,sha256=jLNHGmfLCF4sFk01LQ0yUCYyPDiSiyyjtkmRu8Qysmc,244
+controller/app/api/public/repos.py,sha256=lsRQFNFEo5koiezskzLalTuv19YQO_EdWVG9pLJg-Wg,9087
+controller/app/api/public/terminals.py,sha256=n0QOHw2WT1ozqKh_LqUHysDVZ9VeHG3zMvoZA20w0wY,2365
+controller/app/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/core/config.py,sha256=cWBLY43Y49eBuFRWSBvjueXBpTkMDIUyBEqyl1-FHFc,560
+controller/app/core/errors.py,sha256=D6KFR3llcvaSDEdJTZtRZh7ONREEfUlGDLVt1q4YW0M,404
+controller/app/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/db/models.py,sha256=woNGECTOCIwrAT9HSLLHXNZVTejc3Cd_hBg_-6keZtw,722
+controller/app/db/session.py,sha256=DHGrcYmrCLb7b_0IBmxuaJUAA03yRnWrvHl_V0K_H3o,2759
+controller/app/schemas/__init__.py,sha256=-G-eagWihlL-tJxVe6hKt_v94dAx3swVKd91DLxyXIQ,520
+controller/app/schemas/agent_messages.py,sha256=MPSxQVhkw__IIqsqeS-j46OsUHjvWT_WJH4qnE42lcA,445
+controller/app/schemas/public.py,sha256=etpMQUTTaLIw33f2rI_XAVhRfl398P7GyUlwLBzUyiU,131
+controller/app/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+controller/app/services/agents.py,sha256=ocPa2Bcv5WatyTPTiYAjWGDJfIC52C9y3S3i643wfA4,4841
+controller/app/services/registrations.py,sha256=rzc_Wv-YczoNSRE3XpDCLLQLhfP9Hyb9c_npublhcWA,742
+controller/app/services/repositories.py,sha256=soQkGdkXQz0r2ZcutJ3SNAlty1XBJhsP-nqfL4rodQs,3659
+controller/app/services/router.py,sha256=_Nx48mvusDiQm9Fj_a8hrC0BZevkMn6rUNoLw3ga2SQ,5406
+controller/app/services/tasks.py,sha256=mevkv9ofQWARuSres9PLgP6jKX0_-maW9tS_4C4iyUk,4673
+controller/app/services/terminals.py,sha256=jYDqF9Eo9gQaI8teBdUziBKPYzyl5iwDq0K6LaRWxHY,5890
+shared/__init__.py,sha256=2hU3m0yWwYevIoOEJqkoumqVGW4CGrQIYHE_q1ftpbk,899
+shared/protocol.py,sha256=7sTnV0tHGoRND6SjbTrASE1HEuLG3TJ-CF4l5QqRxm0,6925
+bamboo_coding-0.1.0.dist-info/METADATA,sha256=2y_tje1EBwqmtLfoazs4SvaA78q2_5-YzPPTnR4EI7M,8493
+bamboo_coding-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bamboo_coding-0.1.0.dist-info/entry_points.txt,sha256=LYwgfzzCTbCjBo3iImfUbBYSjXf2NkscFv6FA4IxHvQ,119
+bamboo_coding-0.1.0.dist-info/top_level.txt,sha256=oWwVpBlYKI-qdAPqf9XWLBCjLfKxN2W_D3gNJo8_pVo,52
+bamboo_coding-0.1.0.dist-info/RECORD,,