Implement issue #94b: codehive code connects to backend

CLI probes backend health, creates/resumes project+session via API.
Two CodeApp modes: backend (POST messages, stream via WS) and local
(NativeEngine fallback). --session and --new flags. Tests added.

Author: alexeygrigorev

backend/codehive/cli.py

@@ -466,6 +466,19 @@ def main() -> None:
         default=False,
         help="Skip all tool confirmation prompts",
     )
+    # Mutually exclusive session flags
+    code_session_group = code_parser.add_mutually_exclusive_group()
+    code_session_group.add_argument(
+        "--session",
+        default=None,
+        help="Connect to a specific existing session (UUID)",
+    )
+    code_session_group.add_argument(
+        "--new",
+        action="store_true",
+        default=False,
+        help="Always create a new session (don't resume the latest)",
+    )
 
     # providers subcommand group
     providers_parser = subparsers.add_parser("providers", help="Manage LLM providers")
@@ -640,8 +653,113 @@ def _resolve_provider(args: argparse.Namespace) -> tuple[str, str, str]:
     return api_key, base_url, model
 
 
+def _probe_backend(backend_url: str) -> bool:
+    """Probe GET /api/system/health on the backend. Returns True if reachable and 200."""
+    try:
+        resp = httpx.get(f"{backend_url}/api/system/health", timeout=3.0)
+        return resp.status_code == 200
+    except (httpx.ConnectError, httpx.TimeoutException, httpx.ConnectTimeout):
+        return False
+    except Exception:
+        return False
+
+
+def _resolve_project_and_session(
+    backend_url: str,
+    project_dir: str,
+    session_flag: str | None,
+    new_flag: bool,
+) -> tuple[str, str]:
+    """Resolve project_id and session_id from the backend.
+
+    Returns (project_id, session_id) as strings.
+    Raises SystemExit on errors.
+    """
+    import uuid as _uuid
+
+    client = httpx.Client(base_url=backend_url, timeout=30.0)
+
+    # Get or create project by path
+    try:
+        resp = client.post("/api/projects/by-path", json={"path": project_dir})
+    except httpx.ConnectError:
+        print("Backend not available, starting local-only session", file=sys.stderr)
+        raise SystemExit(None)
+
+    if resp.status_code not in (200, 201):
+        print(
+            f"Warning: Failed to resolve project (HTTP {resp.status_code}), "
+            "starting local-only session",
+            file=sys.stderr,
+        )
+        raise SystemExit(None)
+
+    project = resp.json()
+    project_id = project["id"]
+
+    # Session resolution
+    if session_flag:
+        # Validate it looks like a UUID
+        try:
+            _uuid.UUID(session_flag)
+        except ValueError:
+            print(f"Error: Invalid session UUID: {session_flag}", file=sys.stderr)
+            sys.exit(1)
+        session_id = session_flag
+    elif new_flag:
+        resp = client.post(
+            f"/api/projects/{project_id}/sessions",
+            json={"name": "code-session", "engine": "native", "mode": "execution"},
+        )
+        if resp.status_code not in (200, 201):
+            print(
+                f"Warning: Failed to create session (HTTP {resp.status_code}), "
+                "starting local-only session",
+                file=sys.stderr,
+            )
+            raise SystemExit(None)
+        session_id = resp.json()["id"]
+    else:
+        # List sessions, pick most recent
+        resp = client.get(f"/api/projects/{project_id}/sessions")
+        if resp.status_code == 200:
+            sessions = resp.json()
+            if sessions:
+                # Pick the most recent by created_at
+                most_recent = max(sessions, key=lambda s: s.get("created_at", ""))
+                session_id = most_recent["id"]
+            else:
+                # No sessions exist, create one
+                resp = client.post(
+                    f"/api/projects/{project_id}/sessions",
+                    json={
+                        "name": "code-session",
+                        "engine": "native",
+                        "mode": "execution",
+                    },
+                )
+                if resp.status_code not in (200, 201):
+                    print(
+                        f"Warning: Failed to create session (HTTP {resp.status_code}), "
+                        "starting local-only session",
+                        file=sys.stderr,
+                    )
+                    raise SystemExit(None)
+                session_id = resp.json()["id"]
+        else:
+            print(
+                f"Warning: Failed to list sessions (HTTP {resp.status_code}), "
+                "starting local-only session",
+                file=sys.stderr,
+            )
+            raise SystemExit(None)
+
+    client.close()
+    return project_id, session_id
+
+
 def _code(args: argparse.Namespace) -> None:
-    import os
+    import uuid as _uuid
 
     from codehive.clients.terminal.code_app import CodeApp
 
@@ -650,23 +768,59 @@ def _code(args: argparse.Namespace) -> None:
         print(f"Error: {project_dir} is not a directory", file=sys.stderr)
         sys.exit(1)
 
-    api_key, base_url, model = _resolve_provider(args)
+    backend_url = _get_base_url(args)
+    session_flag = getattr(args, "session", None)
+    new_flag = getattr(args, "new", False)
 
-    if not api_key:
+    # Probe backend
+    backend_available = _probe_backend(backend_url)
+
+    if not backend_available:
         print(
-            "Error: No API key found. Set CODEHIVE_ANTHROPIC_API_KEY or "
-            "ANTHROPIC_API_KEY environment variable.",
+            "Backend not available, starting local-only session",
             file=sys.stderr,
         )
-        sys.exit(1)
 
-    app = CodeApp(
-        project_dir=project_dir,
-        model=model,
-        api_key=api_key,
-        base_url=base_url,
-        auto_approve=getattr(args, "auto_approve", False),
-    )
+    if backend_available:
+        try:
+            project_id, session_id = _resolve_project_and_session(
+                backend_url, project_dir, session_flag, new_flag
+            )
+        except SystemExit:
+            # Fall back to local mode
+            backend_available = False
+            project_id = None
+            session_id = None
+        else:
+            project_id_uuid = _uuid.UUID(project_id)
+            session_id_uuid = _uuid.UUID(session_id)
+
+    if backend_available:
+        app = CodeApp(
+            project_dir=project_dir,
+            auto_approve=getattr(args, "auto_approve", False),
+            backend_url=backend_url,
+            project_id=project_id_uuid,  # type: ignore[possibly-undefined]
+            session_id=session_id_uuid,  # type: ignore[possibly-undefined]
+        )
+    else:
+        api_key, base_url, model = _resolve_provider(args)
+
+        if not api_key:
+            print(
+                "Error: No API key found. Set CODEHIVE_ANTHROPIC_API_KEY or "
+                "ANTHROPIC_API_KEY environment variable.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        app = CodeApp(
+            project_dir=project_dir,
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+            auto_approve=getattr(args, "auto_approve", False),
+        )
     app.run()
 
 

backend/codehive/clients/terminal/code_app.py

@@ -199,6 +199,9 @@ def __init__(
         api_key: str = "",
         base_url: str = "",
         auto_approve: bool = False,
+        backend_url: str | None = None,
+        session_id: uuid.UUID | None = None,
+        project_id: uuid.UUID | None = None,
         **kwargs: object,
     ) -> None:
         super().__init__(**kwargs)  # type: ignore[arg-type]
@@ -210,13 +213,15 @@ def __init__(
         self._always_approved: set[str] = set()
         self._approval_event: asyncio.Event = asyncio.Event()
         self._approval_result: str = ""
-        self._session_id = uuid.uuid4()
+        self._session_id = session_id or uuid.uuid4()
         self._engine: Any = None
         self._busy = False
         self._streaming_widget: _AssistantMarkdown | None = None
         self._streaming_buffer: str = ""
         self._user_scrolled_up = False
         self._awaiting_approval = False
+        self._backend_url: str | None = backend_url
+        self._project_id: uuid.UUID | None = project_id
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=True)
@@ -232,6 +237,11 @@ async def on_mount(self) -> None:
         self.query_one("#code-input", _ChatInput).focus()
 
     async def _init_engine(self) -> None:
+        if self._backend_url is not None:
+            # Backend mode: no local engine needed
+            self._engine = None
+            return
+
         from codehive.engine.native import NativeEngine
         from codehive.execution.diff import DiffService
         from codehive.execution.file_ops import FileOps
@@ -432,13 +442,71 @@ def action_clear_chat(self) -> None:
     async def action_new_session(self) -> None:
         """Start a new session -- reset engine state and clear the UI."""
         self.action_clear_chat()
-        self._session_id = uuid.uuid4()
         self._always_approved = set()
-        if self._engine is not None:
-            await self._engine.create_session(self._session_id)
+
+        if self._backend_url is not None and self._project_id is not None:
+            # Backend mode: create a new session via the API
+            import httpx as _httpx
+
+            try:
+                async with _httpx.AsyncClient(base_url=self._backend_url, timeout=30.0) as client:
+                    resp = await client.post(
+                        f"/api/projects/{self._project_id}/sessions",
+                        json={
+                            "name": "code-session",
+                            "engine": "native",
+                            "mode": "execution",
+                        },
+                    )
+                    if resp.status_code in (200, 201):
+                        self._session_id = uuid.UUID(resp.json()["id"])
+                    else:
+                        self._append_system(
+                            f"Failed to create new session (HTTP {resp.status_code})"
+                        )
+                        return
+            except Exception as exc:
+                self._append_system(f"Error creating session: {exc}")
+                return
+        else:
+            self._session_id = uuid.uuid4()
+            if self._engine is not None:
+                await self._engine.create_session(self._session_id)
+
         self._append_system(f"New session started in {self._project_dir}")
         self._set_status(f"[dim]project: {self._project_dir}[/dim]")
 
+    # ---- Backend message sending ------------------------------------------
+
+    async def _send_backend_message(self, message: str) -> Any:
+        """Send a message to the backend API and yield events from the response."""
+        import httpx as _httpx
+
+        async with _httpx.AsyncClient(
+            base_url=self._backend_url,  # type: ignore[arg-type]
+            timeout=300.0,
+        ) as client:
+            resp = await client.post(
+                f"/api/sessions/{self._session_id}/messages",
+                json={"content": message},
+            )
+            if resp.status_code != 200:
+                detail = ""
+                try:
+                    detail = resp.json().get("detail", resp.text)
+                except Exception:
+                    detail = resp.text
+                yield {
+                    "type": "message.created",
+                    "role": "assistant",
+                    "content": f"Error from backend (HTTP {resp.status_code}): {detail}",
+                }
+                return
+
+            events = resp.json()
+            for event in events:
+                yield event
+
     # ---- Event handling ---------------------------------------------------
 
     async def on__chat_input_submitted(self, event: _ChatInput.Submitted) -> None:
@@ -477,7 +545,11 @@ async def _run_agent(self, message: str) -> None:
         t_start = time.monotonic()
         received_deltas = False
         try:
-            async for event in self._engine.send_message(self._session_id, message):
+            if self._backend_url is not None:
+                event_iter = self._send_backend_message(message)
+            else:
+                event_iter = self._engine.send_message(self._session_id, message)
+            async for event in event_iter:
                 etype = event.get("type", "")
 
                 if etype == "message.delta" and event.get("role") == "assistant":