powerbase-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: powerbase-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: CLI for operating Powerbase console workflows
 Author: Powerbase
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: curl_cffi
 
 # powerbase-cli
 
@@ -41,12 +42,10 @@ Database model:
 Install from PyPI:
 
 ```bash
-python -m pip install --upgrade powerbase-cli==0.2.0
+python3 -m pip install powerbase-cli
 powerbase --help
 ```
 
-Version `0.2.x` is the production-pinned release line and always targets `https://console.appbuild.chat`.
-
 From the repository root during development:
 
 ```bash

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/README.md

@@ -33,12 +33,10 @@ Database model:
 Install from PyPI:
 
 ```bash
-python -m pip install --upgrade powerbase-cli==0.2.0
+python3 -m pip install powerbase-cli
 powerbase --help
 ```
 
-Version `0.2.x` is the production-pinned release line and always targets `https://console.appbuild.chat`.
-
 From the repository root during development:
 
 ```bash

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "powerbase-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "CLI for operating Powerbase console workflows"
 readme = "README.md"
 requires-python = ">=3.11"
 authors = [{ name = "Powerbase" }]
-dependencies = []
+dependencies = ["curl_cffi"]
 
 [project.scripts]
 powerbase = "powerbase_cli.cli:main"

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli/api.py

@@ -137,19 +137,24 @@ class PowerbaseApi:
             instance_id=instance_id,
             stream=True,
         )
-        buffer = ""
-        while True:
-            chunk = resp.readline()
-            if not chunk:
-                break
-            line = chunk.decode("utf-8")
-            if line == "\n":
-                buffer = ""
-                continue
-            if line.startswith("data:"):
-                payload = line[5:].strip()
-                if payload:
-                    yield json.loads(payload)
+        try:
+            buffer = ""
+            while True:
+                chunk = resp.readline()
+                if not chunk:
+                    break
+                line = chunk.decode("utf-8")
+                if line == "\n":
+                    buffer = ""
+                    continue
+                if line.startswith("data:"):
+                    payload = line[5:].strip()
+                    if payload:
+                        yield json.loads(payload)
+        finally:
+            close = getattr(resp, "close", None)
+            if callable(close):
+                close()
 
     def sandbox_files_list(self, instance_id: str, path: str = "/", include_hidden: bool = False) -> Any:
         params = {
@@ -337,12 +342,17 @@ class PowerbaseApi:
             instance_id=instance_id,
             stream=True,
         )
-        while True:
-            chunk = resp.readline()
-            if not chunk:
-                break
-            line = chunk.decode("utf-8")
-            if line.startswith("data:"):
-                payload = line[5:].strip()
-                if payload:
-                    yield json.loads(payload)
+        try:
+            while True:
+                chunk = resp.readline()
+                if not chunk:
+                    break
+                line = chunk.decode("utf-8")
+                if line.startswith("data:"):
+                    payload = line[5:].strip()
+                    if payload:
+                        yield json.loads(payload)
+        finally:
+            close = getattr(resp, "close", None)
+            if callable(close):
+                close()

powerbase_cli-0.2.2/src/powerbase_cli/http_client.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from curl_cffi import requests
+from curl_cffi.requests.exceptions import RequestException
+
+DEFAULT_TIMEOUT_SECONDS = 30
+DEFAULT_IMPERSONATION = "chrome"
+
+
+@dataclass
+class HttpClientError(RuntimeError):
+    message: str
+    status_code: int | None = None
+    body_text: str | None = None
+    reason: str | None = None
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class StreamResponseAdapter:
+    def __init__(self, response: requests.Response) -> None:
+        self._response = response
+        self._lines = response.iter_lines()
+
+    def readline(self) -> bytes:
+        try:
+            line = next(self._lines)
+        except StopIteration:
+            self.close()
+            return b""
+        if isinstance(line, str):
+            return line.encode("utf-8") + b"\n"
+        return line + b"\n"
+
+    def close(self) -> None:
+        self._response.close()
+
+
+def send_request(
+    method: str,
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    body: bytes | None = None,
+    stream: bool = False,
+    timeout: int = DEFAULT_TIMEOUT_SECONDS,
+) -> Any:
+    try:
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            data=body,
+            stream=stream,
+            timeout=timeout,
+            impersonate=DEFAULT_IMPERSONATION,
+        )
+    except RequestException as exc:
+        raise HttpClientError(
+            message=str(exc),
+            reason=str(exc),
+        ) from exc
+
+    if response.status_code >= 400:
+        body_text = response.text
+        raise HttpClientError(
+            message=body_text or f"HTTP {response.status_code}",
+            status_code=response.status_code,
+            body_text=body_text,
+            reason=body_text or response.reason,
+        )
+
+    if stream:
+        return StreamResponseAdapter(response)
+    return response
+
+
+def request_json(
+    method: str,
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    body: bytes | None = None,
+    timeout: int = DEFAULT_TIMEOUT_SECONDS,
+) -> dict[str, Any]:
+    response = send_request(
+        method,
+        url,
+        headers=headers,
+        body=body,
+        timeout=timeout,
+    )
+    raw = response.text
+    return json.loads(raw) if raw else {}

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli/session.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
 import json
-import ssl
 import time
 from contextlib import contextmanager
 from dataclasses import replace
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Iterator
-from urllib import request
-from urllib.error import HTTPError, URLError
 
 from .config import AuthState, ConfigStore, env_auth_state
+from .http_client import HttpClientError, request_json
 
 try:
     import fcntl
@@ -41,9 +39,6 @@ class SessionManager:
             "run `powerbase auth wait --login-id ... --json`."
         )
 
-    def _urlopen(self, req: request.Request):
-        return request.urlopen(req)
-
     def get_auth_state(self) -> AuthState | None:
         return env_auth_state() or self.store.load_auth()
 
@@ -79,25 +74,19 @@ class SessionManager:
             raise SessionError("base_url and anon_key are required to refresh the session.")
 
         payload = json.dumps({"refresh_token": auth.session.refresh_token}).encode("utf-8")
-        req = request.Request(
-            f"{self.base_url.rstrip('/')}/auth/v1/token?grant_type=refresh_token",
-            data=payload,
-            headers={
-                "apikey": self.anon_key,
-                "Content-Type": "application/json",
-            },
-            method="POST",
-        )
         try:
-            with self._urlopen(req) as resp:
-                data = json.loads(resp.read().decode("utf-8"))
-        except HTTPError as exc:  # pragma: no cover - exercised via tests with patched urlopen
-            body = exc.read().decode("utf-8", errors="replace")
-            raise SessionError(f"Failed to refresh session: {body}") from exc
-        except URLError as exc:  # pragma: no cover - depends on runtime/network setup
-            raise SessionError(f"Failed to refresh session: {exc.reason}") from exc
-        except ssl.SSLError as exc:  # pragma: no cover - depends on runtime/network setup
-            raise SessionError(f"Failed to refresh session: {exc}") from exc
+            data = request_json(
+                "POST",
+                f"{self.base_url.rstrip('/')}/auth/v1/token?grant_type=refresh_token",
+                body=payload,
+                headers={
+                    "apikey": self.anon_key,
+                    "Content-Type": "application/json",
+                },
+            )
+        except HttpClientError as exc:  # pragma: no cover - exercised via tests with patched request_json
+            detail = exc.body_text or exc.reason or str(exc)
+            raise SessionError(f"Failed to refresh session: {detail}") from exc
 
         new_auth = AuthState(
             source=auth.source,

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli/transport.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 import json
-import ssl
 from dataclasses import dataclass
 from typing import Any
-from urllib import request
-from urllib.error import HTTPError, URLError
 
 from .config import AppConfig
+from .http_client import HttpClientError, send_request
 from .session import SessionError, SessionManager
 
 
@@ -34,9 +32,6 @@ class PowerbaseTransport:
             "run `powerbase auth wait --login-id ... --json`."
         )
 
-    def _urlopen(self, req: request.Request):
-        return request.urlopen(req)
-
     def _build_headers(
         self,
         *,
@@ -56,24 +51,43 @@ class PowerbaseTransport:
             request_headers.update(headers)
         return request_headers
 
-    def _send(self, req: request.Request, *, stream: bool) -> Any:
-        resp = self._urlopen(req)
+    def _send(
+        self,
+        *,
+        method: str,
+        url: str,
+        payload: bytes | None,
+        headers: dict[str, str],
+        stream: bool,
+    ) -> Any:
+        resp = send_request(
+            method=method,
+            url=url,
+            body=payload,
+            headers=headers,
+            stream=stream,
+        )
         if stream:
             return resp
-        raw = resp.read().decode("utf-8")
+        raw = resp.text
         return json.loads(raw) if raw else {}
 
-    def _parse_http_error(self, exc: HTTPError) -> ApiError:
-        body_text = exc.read().decode("utf-8", errors="replace")
+    def _parse_http_error(self, exc: HttpClientError) -> ApiError:
+        body_text = exc.body_text or exc.reason or str(exc)
         try:
             data = json.loads(body_text)
         except json.JSONDecodeError:
             data = {"error": body_text}
-        message = data.get("error") or body_text or exc.reason
-        if exc.code == 401:
+        error_text = str(data.get("error") or "").strip()
+        detail_text = str(data.get("message") or "").strip()
+        if error_text and detail_text and detail_text != error_text:
+            message = f"{error_text}: {detail_text}"
+        else:
+            message = error_text or detail_text or body_text or exc.reason
+        if exc.status_code == 401:
             base_message = str(message).strip() or "Authentication failed."
             message = f"{base_message} {self._login_guidance()}"
-        return ApiError(str(message), exc.code)
+        return ApiError(str(message), exc.status_code)
 
     def invoke(
         self,
@@ -104,12 +118,18 @@ class PowerbaseTransport:
             headers=headers,
             instance_id=instance_id,
         )
-        req = request.Request(url, data=payload, headers=request_headers, method=method.upper())
+        request_method = method.upper()
 
         try:
-            return self._send(req, stream=stream)
-        except HTTPError as exc:
-            if exc.code == 401 and auth and auth.session.refresh_token:
+            return self._send(
+                method=request_method,
+                url=url,
+                payload=payload,
+                headers=request_headers,
+                stream=stream,
+            )
+        except HttpClientError as exc:
+            if exc.status_code == 401 and auth and auth.session.refresh_token:
                 try:
                     refreshed_auth = self.session_manager.refresh(auth)
                 except SessionError as refresh_error:
@@ -119,14 +139,15 @@ class PowerbaseTransport:
                     headers=headers,
                     instance_id=instance_id,
                 )
-                retry_req = request.Request(url, data=payload, headers=retry_headers, method=method.upper())
                 try:
-                    return self._send(retry_req, stream=stream)
-                except HTTPError as retry_exc:
+                    return self._send(
+                        method=request_method,
+                        url=url,
+                        payload=payload,
+                        headers=retry_headers,
+                        stream=stream,
+                    )
+                except HttpClientError as retry_exc:
                     raise self._parse_http_error(retry_exc) from retry_exc
             raise self._parse_http_error(exc) from exc
-        except URLError as exc:
-            raise ApiError(f"Request failed: {exc.reason}") from exc
-        except ssl.SSLError as exc:
-            raise ApiError(f"Request failed: {exc}") from exc
 

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli.egg-info/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: powerbase-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: CLI for operating Powerbase console workflows
 Author: Powerbase
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: curl_cffi
 
 # powerbase-cli
 
@@ -41,12 +42,10 @@ Database model:
 Install from PyPI:
 
 ```bash
-python -m pip install --upgrade powerbase-cli==0.2.0
+python3 -m pip install powerbase-cli
 powerbase --help
 ```
 
-Version `0.2.x` is the production-pinned release line and always targets `https://console.appbuild.chat`.
-
 From the repository root during development:
 
 ```bash

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/src/powerbase_cli.egg-info/SOURCES.txt

@@ -5,12 +5,14 @@ src/powerbase_cli/__main__.py
 src/powerbase_cli/api.py
 src/powerbase_cli/cli.py
 src/powerbase_cli/config.py
+src/powerbase_cli/http_client.py
 src/powerbase_cli/session.py
 src/powerbase_cli/transport.py
 src/powerbase_cli.egg-info/PKG-INFO
 src/powerbase_cli.egg-info/SOURCES.txt
 src/powerbase_cli.egg-info/dependency_links.txt
 src/powerbase_cli.egg-info/entry_points.txt
+src/powerbase_cli.egg-info/requires.txt
 src/powerbase_cli.egg-info/top_level.txt
 src/powerbase_cli/commands/__init__.py
 src/powerbase_cli/commands/agent.py
@@ -30,5 +32,6 @@ tests/test_api.py
 tests/test_cli_commands.py
 tests/test_cli_help.py
 tests/test_config.py
+tests/test_http_client.py
 tests/test_session.py
 tests/test_transport.py

powerbase_cli-0.2.2/src/powerbase_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+curl_cffi

powerbase_cli-0.2.2/tests/test_http_client.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from powerbase_cli.http_client import StreamResponseAdapter
+
+
+class FakeStreamResponse:
+    def __init__(self, lines: list[bytes | str]) -> None:
+        self.lines = lines
+        self.closed = False
+
+    def iter_lines(self):
+        yield from self.lines
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class HttpClientTests(unittest.TestCase):
+    def test_stream_response_adapter_reads_lines_and_closes(self) -> None:
+        response = FakeStreamResponse([b"data: one", b"", "data: two"])
+        adapter = StreamResponseAdapter(response)
+
+        self.assertEqual(adapter.readline(), b"data: one\n")
+        self.assertEqual(adapter.readline(), b"\n")
+        self.assertEqual(adapter.readline(), b"data: two\n")
+        self.assertEqual(adapter.readline(), b"")
+        self.assertTrue(response.closed)

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/tests/test_session.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import os
 import sys
 import tempfile
@@ -11,23 +10,10 @@ from unittest import mock
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
 from powerbase_cli.config import AuthSession, AuthState, ConfigStore
+from powerbase_cli.http_client import HttpClientError
 from powerbase_cli.session import SessionError, SessionManager
 
 
-class FakeResponse:
-    def __init__(self, payload: dict[str, object]) -> None:
-        self.payload = payload
-
-    def __enter__(self) -> "FakeResponse":
-        return self
-
-    def __exit__(self, exc_type, exc, tb) -> None:
-        return None
-
-    def read(self) -> bytes:
-        return json.dumps(self.payload).encode("utf-8")
-
-
 class SessionManagerTests(unittest.TestCase):
     def test_refresh_without_auth_instructs_user_to_log_in_again(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -58,13 +44,13 @@ class SessionManagerTests(unittest.TestCase):
             )
             manager = SessionManager(store, "https://console.example.com", "anon")
 
-            with mock.patch("powerbase_cli.session.request.urlopen", return_value=FakeResponse({
+            with mock.patch("powerbase_cli.session.request_json", return_value={
                 "access_token": "new-access",
                 "refresh_token": "new-refresh",
                 "expires_at": 9999999999,
                 "token_type": "bearer",
                 "user": {"id": "user-1"},
-            })):
+            }):
                 refreshed = manager.refresh()
 
             self.assertEqual(refreshed.session.access_token, "new-access")
@@ -81,12 +67,12 @@ class SessionManagerTests(unittest.TestCase):
                 os.environ["POWERBASE_ACCESS_TOKEN"] = "env-access"
                 os.environ["POWERBASE_REFRESH_TOKEN"] = "env-refresh"
                 os.environ["POWERBASE_EXPIRES_AT"] = "1"
-                with mock.patch("powerbase_cli.session.request.urlopen", return_value=FakeResponse({
+                with mock.patch("powerbase_cli.session.request_json", return_value={
                     "access_token": "env-new-access",
                     "refresh_token": "env-new-refresh",
                     "expires_at": 9999999999,
                     "token_type": "bearer",
-                })):
+                }):
                     refreshed = manager.ensure_valid()
                 assert refreshed is not None
                 self.assertEqual(refreshed.session.access_token, "env-new-access")
@@ -95,3 +81,29 @@ class SessionManagerTests(unittest.TestCase):
                 os.environ.clear()
                 os.environ.update(old_env)
 
+    def test_refresh_wraps_http_client_errors(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            store = ConfigStore(Path(temp_dir))
+            store.save_auth(
+                AuthState(
+                    source="login",
+                    base_url="https://console.example.com",
+                    anon_key="anon",
+                    session=AuthSession(
+                        access_token="old-access",
+                        refresh_token="old-refresh",
+                        expires_at=1,
+                    ),
+                )
+            )
+            manager = SessionManager(store, "https://console.example.com", "anon")
+
+            with mock.patch(
+                "powerbase_cli.session.request_json",
+                side_effect=HttpClientError(message="tls failed", reason="tls failed"),
+            ):
+                with self.assertRaises(SessionError) as ctx:
+                    manager.refresh()
+
+            self.assertIn("tls failed", str(ctx.exception))
+

{powerbase_cli-0.2.0 → powerbase_cli-0.2.2}/tests/test_transport.py

@@ -1,36 +1,30 @@
 from __future__ import annotations
 
-import io
-import json
 import sys
 import tempfile
 import unittest
 from pathlib import Path
 from unittest import mock
-from urllib.error import HTTPError, URLError
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
 from powerbase_cli.config import AppConfig, AuthSession, AuthState, ConfigStore
+from powerbase_cli.http_client import HttpClientError
 from powerbase_cli.session import SessionManager
 from powerbase_cli.transport import ApiError, PowerbaseTransport
 
 
 class FakeResponse:
-    def __init__(self, payload: dict[str, object]) -> None:
-        self.payload = payload
+    def __init__(self, text: str) -> None:
+        self.text = text
 
-    def read(self) -> bytes:
-        return json.dumps(self.payload).encode("utf-8")
 
-
-def build_http_error(status: int, payload: dict[str, object]) -> HTTPError:
-    return HTTPError(
-        url="https://console.example.com/functions/v1/instances",
-        code=status,
-        msg="error",
-        hdrs=None,
-        fp=io.BytesIO(json.dumps(payload).encode("utf-8")),
+def build_http_error(status: int, payload_text: str) -> HttpClientError:
+    return HttpClientError(
+        message=payload_text,
+        status_code=status,
+        body_text=payload_text,
+        reason=payload_text,
     )
 
 
@@ -41,7 +35,7 @@ class PowerbaseTransportTests(unittest.TestCase):
             manager = SessionManager(store, "https://console.example.com", "anon")
             transport = PowerbaseTransport(AppConfig(base_url="https://console.example.com", anon_key="anon"), manager)
 
-            with mock.patch("powerbase_cli.transport.request.urlopen") as urlopen_mock:
+            with mock.patch("powerbase_cli.transport.send_request") as request_mock:
                 with self.assertRaises(ApiError) as ctx:
                     transport.invoke("instances", method="GET")
 
@@ -49,7 +43,7 @@ class PowerbaseTransportTests(unittest.TestCase):
         self.assertIn("No authentication session available", str(ctx.exception))
         self.assertIn("powerbase auth login --json", str(ctx.exception))
         self.assertIn("powerbase auth wait --login-id ... --json", str(ctx.exception))
-        self.assertEqual(urlopen_mock.call_count, 0)
+        self.assertEqual(request_mock.call_count, 0)
 
     def test_invoke_refreshes_and_retries_once_on_401(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -79,19 +73,19 @@ class PowerbaseTransportTests(unittest.TestCase):
                     expires_at=9999999999,
                 ),
             )) as refresh_mock:
-                with mock.patch("powerbase_cli.transport.request.urlopen") as urlopen_mock:
-                    urlopen_mock.side_effect = [
-                        build_http_error(401, {"error": "expired"}),
-                        FakeResponse({"success": True, "data": {"ok": True}}),
+                with mock.patch("powerbase_cli.transport.send_request") as request_mock:
+                    request_mock.side_effect = [
+                        build_http_error(401, '{"error":"expired"}'),
+                        FakeResponse('{"success": true, "data": {"ok": true}}'),
                     ]
 
                     result = transport.invoke("instances", method="GET")
 
             self.assertEqual(result["data"]["ok"], True)
             self.assertEqual(refresh_mock.call_count, 1)
-            self.assertEqual(urlopen_mock.call_count, 2)
-            first_auth = urlopen_mock.call_args_list[0].args[0].headers["Authorization"]
-            second_auth = urlopen_mock.call_args_list[1].args[0].headers["Authorization"]
+            self.assertEqual(request_mock.call_count, 2)
+            first_auth = request_mock.call_args_list[0].kwargs["headers"]["Authorization"]
+            second_auth = request_mock.call_args_list[1].kwargs["headers"]["Authorization"]
             self.assertEqual(first_auth, "Bearer stale-access")
             self.assertEqual(second_auth, "Bearer fresh-access")
 
@@ -111,9 +105,9 @@ class PowerbaseTransportTests(unittest.TestCase):
 
             with mock.patch.object(manager, "refresh") as refresh_mock:
                 with mock.patch(
-                    "powerbase_cli.transport.request.urlopen",
-                    side_effect=build_http_error(401, {"error": "expired"}),
-                ) as urlopen_mock:
+                    "powerbase_cli.transport.send_request",
+                    side_effect=build_http_error(401, '{"error":"expired"}'),
+                ) as request_mock:
                     with self.assertRaises(ApiError) as ctx:
                         transport.invoke("instances", method="GET")
 
@@ -121,7 +115,7 @@ class PowerbaseTransportTests(unittest.TestCase):
             self.assertIn("powerbase auth login --json", str(ctx.exception))
             self.assertIn("powerbase auth wait --login-id ... --json", str(ctx.exception))
             self.assertEqual(refresh_mock.call_count, 0)
-            self.assertEqual(urlopen_mock.call_count, 1)
+            self.assertEqual(request_mock.call_count, 1)
 
     def test_invoke_wraps_url_errors(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -129,8 +123,30 @@ class PowerbaseTransportTests(unittest.TestCase):
             manager = SessionManager(store, "https://console.example.com", "anon")
             transport = PowerbaseTransport(AppConfig(base_url="https://console.example.com", anon_key="anon"), manager)
 
-            with mock.patch("powerbase_cli.transport.request.urlopen", side_effect=URLError("tls failed")):
+            with mock.patch(
+                "powerbase_cli.transport.send_request",
+                side_effect=HttpClientError(message="tls failed", reason="tls failed"),
+            ):
                 with self.assertRaises(ApiError) as ctx:
                     transport.invoke("instances", method="GET", requires_auth=False)
 
             self.assertIn("tls failed", str(ctx.exception))
+
+    def test_invoke_preserves_server_error_detail(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            store = ConfigStore(Path(temp_dir))
+            manager = SessionManager(store, "https://console.example.com", "anon")
+            transport = PowerbaseTransport(AppConfig(base_url="https://console.example.com", anon_key="anon"), manager)
+
+            with mock.patch(
+                "powerbase_cli.transport.send_request",
+                side_effect=build_http_error(
+                    500,
+                    '{"error":"Internal Server Error","message":"worker boot error: failed to bootstrap runtime"}',
+                ),
+            ):
+                with self.assertRaises(ApiError) as ctx:
+                    transport.invoke("cli-auth/start", method="POST", body={}, requires_auth=False)
+
+            self.assertIn("Internal Server Error", str(ctx.exception))
+            self.assertIn("worker boot error", str(ctx.exception))