powerbase-cli 0.1.0__py3-none-any.whl

powerbase_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Powerbase CLI package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

powerbase_cli/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

powerbase_cli/api.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+from typing import Any, Iterable
+from urllib.parse import urlencode
+
+from .transport import PowerbaseTransport
+
+
+def _response_data(response: dict[str, Any]) -> Any:
+    if response.get("success") is False:
+        raise RuntimeError(response.get("error") or response.get("message") or "Request failed")
+    return response.get("data", response)
+
+
+class PowerbaseApi:
+    def __init__(self, transport: PowerbaseTransport) -> None:
+        self.transport = transport
+
+    def start_cli_login(self) -> dict[str, Any]:
+        return _response_data(
+            self.transport.invoke("cli-auth/start", method="POST", body={}, requires_auth=False)
+        )
+
+    def poll_cli_login(self, login_id: str) -> dict[str, Any]:
+        return _response_data(self.transport.invoke("cli-auth/poll", method="POST", body={"login_id": login_id}, requires_auth=False))
+
+    def list_orgs(self) -> Any:
+        return _response_data(self.transport.invoke("organizations", method="GET"))
+
+    def list_databases(self) -> Any:
+        return _response_data(self.transport.invoke("databases", method="GET"))
+
+    def get_database(self, database_id: str) -> Any:
+        return _response_data(self.transport.invoke(f"databases/{database_id}", method="GET"))
+
+    def create_database(
+        self,
+        name: str,
+        dsn: str,
+        description: str | None = None,
+        db_type: str | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {"name": name, "dsn": dsn}
+        if description:
+            body["description"] = description
+        if db_type:
+            body["db_type"] = db_type
+        return _response_data(self.transport.invoke("databases", method="POST", body=body))
+
+    def update_database(
+        self,
+        database_id: str,
+        name: str | None = None,
+        dsn: str | None = None,
+        description: str | None = None,
+        db_type: str | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if dsn is not None:
+            body["dsn"] = dsn
+        if description is not None:
+            body["description"] = description
+        if db_type is not None:
+            body["db_type"] = db_type
+        return _response_data(self.transport.invoke(f"databases/{database_id}", method="PUT", body=body))
+
+    def delete_database(self, database_id: str) -> Any:
+        return _response_data(self.transport.invoke(f"databases/{database_id}", method="DELETE"))
+
+    def list_instances(self) -> Any:
+        return _response_data(self.transport.invoke("instances", method="GET"))
+
+    def get_instance(self, instance_id: str) -> Any:
+        return _response_data(self.transport.invoke(f"instances/{instance_id}", method="GET"))
+
+    def create_instance(self, name: str | None, database_id: str | None, organization_id: str | None) -> Any:
+        body: dict[str, Any] = {}
+        if name:
+            body["name"] = name
+        if database_id:
+            body["database_id"] = database_id
+        if organization_id:
+            body["organization_id"] = organization_id
+        return _response_data(self.transport.invoke("instances", method="POST", body=body))
+
+    def delete_instance(self, instance_id: str) -> Any:
+        return _response_data(self.transport.invoke(f"instances/{instance_id}", method="DELETE"))
+
+    def list_branches(self, instance_id: str) -> Any:
+        return _response_data(self.transport.invoke(f"instances/{instance_id}/branches", method="GET"))
+
+    def create_branch(self, instance_id: str, branch_name: str, source_branch_slug: str | None) -> Any:
+        body = {
+            "branch_name": branch_name,
+            "source_branch_slug": source_branch_slug or "main",
+        }
+        return _response_data(self.transport.invoke(f"instances/{instance_id}/branches", method="POST", body=body))
+
+    def delete_branch(self, instance_id: str, branch_slug: str) -> Any:
+        return _response_data(self.transport.invoke(f"instances/{instance_id}/branches/{branch_slug}", method="DELETE"))
+
+    def switch_branch(self, instance_id: str, branch_name: str) -> Any:
+        return self.transport.invoke(
+            "sandbox-control/switch-branch",
+            method="POST",
+            body={"instance_id": instance_id, "branch_name": branch_name},
+            instance_id=instance_id,
+        )
+
+    def run_sql(self, instance_id: str, sql: str, branch: str | None) -> Any:
+        return self.transport.invoke(
+            "sql-execute",
+            method="POST",
+            body={"instance_id": instance_id, "sql": sql, "branch": branch or "main"},
+            instance_id=instance_id,
+        )
+
+    def publish_diff(self, instance_id: str, target: str = "prod") -> Any:
+        return self.transport.invoke(
+            f"sandbox-control/promote/diff?target={target}",
+            method="POST",
+            body={"instance_id": instance_id},
+            instance_id=instance_id,
+        )
+
+    def publish_run(self, instance_id: str, sql: str, target: str = "prod") -> Iterable[dict[str, Any]]:
+        resp = self.transport.invoke(
+            f"sandbox-control/promote/execute?target={target}&stream=1",
+            method="POST",
+            body={"instance_id": instance_id, "sql": sql},
+            headers={"Accept": "text/event-stream"},
+            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)
+
+    def sandbox_files_list(self, instance_id: str, path: str = "/", include_hidden: bool = False) -> Any:
+        params = {
+            "path": path,
+            "instance_id": instance_id,
+        }
+        if include_hidden:
+            params["includeHidden"] = "true"
+        suffix = urlencode(params)
+        return self.transport.invoke(f"sandbox-files/list?{suffix}", instance_id=instance_id)
+
+    def sandbox_files_tree(self, instance_id: str, root: str = "/", max_depth: int = 3) -> Any:
+        suffix = urlencode({"root": root, "maxDepth": max_depth, "instance_id": instance_id})
+        return self.transport.invoke(
+            f"sandbox-files/tree?{suffix}",
+            instance_id=instance_id,
+        )
+
+    def sandbox_files_read(self, instance_id: str, path: str) -> Any:
+        suffix = urlencode({"path": path, "instance_id": instance_id})
+        return self.transport.invoke(
+            f"sandbox-files/content?{suffix}",
+            instance_id=instance_id,
+        )
+
+    def sandbox_files_create_file(self, instance_id: str, path: str, content: str) -> Any:
+        return self.transport.invoke(
+            "sandbox-files/create",
+            method="POST",
+            body={"type": "file", "path": path, "content": content, "instance_id": instance_id},
+            instance_id=instance_id,
+        )
+
+    def sandbox_files_create_folder(self, instance_id: str, path: str) -> Any:
+        return self.transport.invoke(
+            "sandbox-files/create",
+            method="POST",
+            body={"type": "folder", "path": path, "instance_id": instance_id},
+            instance_id=instance_id,
+        )
+
+    def sandbox_files_upload(self, instance_id: str, source_path: str, target_path: str) -> Any:
+        file_bytes = Path(source_path).read_bytes()
+        encoded = base64.b64encode(file_bytes).decode("ascii")
+        return self.transport.invoke(
+            "sandbox-files/upload",
+            method="POST",
+            body={
+                "fileName": Path(source_path).name,
+                "fileContent": encoded,
+                "path": target_path,
+                "instance_id": instance_id,
+            },
+            instance_id=instance_id,
+        )
+
+    def sandbox_files_delete(self, instance_id: str, path: str) -> Any:
+        return self.transport.invoke(
+            "sandbox-files/delete",
+            method="POST",
+            body={"path": path, "instance_id": instance_id},
+            instance_id=instance_id,
+        )
+
+    def agent_providers(self, instance_id: str | None) -> Any:
+        return self.transport.invoke(
+            "sandbox-agent/providers",
+            instance_id=instance_id,
+            requires_auth=bool(instance_id),
+        )
+
+    def agent_status(self, instance_id: str, provider: str) -> Any:
+        return self.transport.invoke(
+            f"sandbox-agent/status?provider={provider}",
+            instance_id=instance_id,
+        )
+
+    def agent_login_url(self, instance_id: str, provider: str) -> Any:
+        return self.transport.invoke(
+            f"sandbox-agent/login-url?provider={provider}",
+            method="POST",
+            body={},
+            instance_id=instance_id,
+        )
+
+    def agent_opencode_config_get(self, instance_id: str) -> Any:
+        return self.transport.invoke(
+            "sandbox-agent/opencode-config",
+            method="GET",
+            instance_id=instance_id,
+        )
+
+    def agent_opencode_config_set(
+        self,
+        instance_id: str,
+        provider: str,
+        api_key: str,
+        models: list[dict[str, Any]] | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {"provider": provider, "apiKey": api_key}
+        if models:
+            body["models"] = models
+        return self.transport.invoke(
+            "sandbox-agent/opencode-config",
+            method="POST",
+            body=body,
+            instance_id=instance_id,
+        )
+
+    def agent_opencode_config_delete(self, instance_id: str, provider: str) -> Any:
+        suffix = urlencode({"provider": provider})
+        return self.transport.invoke(
+            f"sandbox-agent/opencode-config?{suffix}",
+            method="DELETE",
+            instance_id=instance_id,
+        )
+
+    def agent_custom_provider_create(
+        self,
+        instance_id: str,
+        provider_id: str,
+        name: str | None,
+        base_url: str,
+        api_key: str,
+        models: list[dict[str, Any]],
+    ) -> Any:
+        body: dict[str, Any] = {
+            "id": provider_id,
+            "baseURL": base_url,
+            "apiKey": api_key,
+            "models": models,
+        }
+        if name:
+            body["name"] = name
+        return self.transport.invoke(
+            "sandbox-agent/opencode-custom-provider",
+            method="POST",
+            body=body,
+            instance_id=instance_id,
+        )
+
+    def agent_custom_provider_delete(self, instance_id: str, provider_id: str) -> Any:
+        suffix = urlencode({"id": provider_id})
+        return self.transport.invoke(
+            f"sandbox-agent/opencode-custom-provider?{suffix}",
+            method="DELETE",
+            instance_id=instance_id,
+        )
+
+    def agent_opencode_json_set(self, instance_id: str, payload: dict[str, Any]) -> Any:
+        return self.transport.invoke(
+            "sandbox-agent/opencode-json",
+            method="POST",
+            body=payload,
+            instance_id=instance_id,
+        )
+
+    def agent_chat(
+        self,
+        instance_id: str,
+        message: str,
+        *,
+        session_id: str | None = None,
+        provider: str | None = None,
+        model: str | None = None,
+        first_user_message: str | None = None,
+        agent: str | None = None,
+    ) -> Iterable[dict[str, Any]]:
+        body: dict[str, Any] = {"message": message}
+        if session_id:
+            body["session_id"] = session_id
+        if provider:
+            body["provider"] = provider
+        if model:
+            body["model"] = model
+        if first_user_message:
+            body["first_user_message"] = first_user_message
+        if agent:
+            body["agent"] = agent
+        resp = self.transport.invoke(
+            "sandbox-agent/chat",
+            method="POST",
+            body=body,
+            headers={"Accept": "text/event-stream"},
+            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)

powerbase_cli/certs/powerbase-test-ca.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDhDCCAmygAwIBAgIUWu1JfeyC2qw56+7PUB5QY9w1MG8wDQYJKoZIhvcNAQEL
+BQAwHjEcMBoGA1UEAwwTNi4xMi4yMzUuMTY1Lm5pcC5pbzAeFw0yNjA0MDcwNTUx
+MjZaFw0yNzA0MDcwNTUxMjZaMB4xHDAaBgNVBAMMEzYuMTIuMjM1LjE2NS5uaXAu
+aW8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVaa9eQzG9t/WNcoP8
+vJDX41oELoz/LOVzmr9zuFK3jQnIrVjFW8MdBHq1pOBLyHjKtnhKPo1n0br4/iPP
+/TiJNwAuybN6iiSxWSsGpzFv7gIyJivdr65khzeLNda6HyBFxsRsVZAKKe8tueB4
+FQM0YWxHkfAMw5bigDumZq3wzLUuvB7EtscVtl0dV0tcqovLq1Lg9/eBDSqfWuxv
+hW9iROv23ryJETE/8Wh/2Gd5UV0E8CEX8As30+5nJ2jGF6O8abDRipvqc67+5v7h
+dEXT2xIg4Fh8DAhlbgzM6Sj6I70pWiro+Q+N8GWvpJeJYGZu7J97eEOw+u1C2pCV
+sbiBAgMBAAGjgbkwgbYwHQYDVR0OBBYEFODuAm1rmrl2GyZBcClH9HVE9kGMMB8G
+A1UdIwQYMBaAFODuAm1rmrl2GyZBcClH9HVE9kGMMA8GA1UdEwEB/wQFMAMBAf8w
+YwYDVR0RBFwwWoITNi4xMi4yMzUuMTY1Lm5pcC5pb4IbY29uc29sZS42LjEyLjIz
+NS4xNjUubmlwLmlvghUqLjYuMTIuMjM1LjE2NS5uaXAuaW+CCWxvY2FsaG9zdIcE
+fwAAATANBgkqhkiG9w0BAQsFAAOCAQEAmvCeJ4Xnx8rXmU+oxiDiDZRfUK204Ta7
+hztXu9LvxheW99p2R1AP2F7VUJOTq31HY9/r2p3qCEyz8F4nc/GPunHfF3y8mMiB
+beFDdwrw8NWTRLGlOJynjsOXtkRkFa03DTKa4x9roZo10S+imDk1/DywWlv7UoAK
+9OsUB1zb8c6m7uZXrOTAZOzvO2fBrdymXnQ4tMvl54iyVT8X1rft5NUywfBzCtzB
+g/OxLM2zJg3kz9kFztRuf1e07Tz6cqSy2CzClvhxaYJSfnlT2b73SceKy3kHn7Sh
+VXA8yjqcTjk6wkMlHueIWnjnjYkRSpFjw3/ODNXbGJjxh+86l/ekPQ==
+-----END CERTIFICATE-----

powerbase_cli/cli.py

@@ -0,0 +1,7 @@
+from .commands.agent import handle_agent_chat
+from .commands.auth import handle_auth_login
+from .commands.parser import build_parser, main
+from .commands.shared import build_api, resolve_config
+
+__all__ = ["build_parser", "main", "build_api", "resolve_config", "handle_auth_login", "handle_agent_chat"]
+

powerbase_cli/commands/__init__.py

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

powerbase_cli/commands/agent.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+from .shared import build_api, load_json_document, load_text, parse_json_specs, render_output, require_instance
+
+
+def handle_agent_providers(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    render_output(args, api.agent_providers(args.instance_id or context.instance_id))
+    return 0
+
+
+def handle_agent_status(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    render_output(args, api.agent_status(require_instance(args.instance_id, context), args.provider))
+    return 0
+
+
+def handle_agent_login_url(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    render_output(args, api.agent_login_url(require_instance(args.instance_id, context), args.provider))
+    return 0
+
+
+def handle_agent_opencode_config_get(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    render_output(args, api.agent_opencode_config_get(require_instance(args.instance_id, context)))
+    return 0
+
+
+def handle_agent_opencode_config_set(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    instance_id = require_instance(args.instance_id, context)
+    models = parse_json_specs(args.model_limit, label="--model-limit entry")
+    render_output(
+        args,
+        api.agent_opencode_config_set(instance_id, args.provider, args.api_key, models or None),
+    )
+    return 0
+
+
+def handle_agent_opencode_config_delete(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    render_output(
+        args,
+        api.agent_opencode_config_delete(require_instance(args.instance_id, context), args.provider),
+    )
+    return 0
+
+
+def handle_agent_opencode_json_set(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    payload = load_json_document(args.file)
+    render_output(
+        args,
+        api.agent_opencode_json_set(require_instance(args.instance_id, context), payload),
+    )
+    return 0
+
+
+def handle_agent_chat(args: argparse.Namespace) -> int:
+    _, _, context, _, api = build_api(args)
+    instance_id = require_instance(args.instance_id, context)
+    message = load_text(
+        args.message,
+        args.message_file,
+        required_message="A chat message is required. Pass --message or --message-file.",
+    )
+    first_user_message = None
+    if args.first_user_message or args.first_user_message_file:
+        first_user_message = load_text(
+            args.first_user_message,
+            args.first_user_message_file,
+            required_message="first_user_message input is missing.",
+        )
+    events = api.agent_chat(
+        instance_id,
+        message,
+        session_id=args.session_id,
+        provider=args.provider,
+        model=args.model,
+        first_user_message=first_user_message,
+        agent=args.agent_name,
+    )
+    if args.stream_jsonl:
+        for event in events:
+            print(json.dumps(event, ensure_ascii=False))
+        return 0
+    render_output(args, {"events": list(events)})
+    return 0
+
+
+def register_agent_commands(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    agent = subparsers.add_parser("agent", help="Agent provider commands.", description="Inspect sandbox agent providers.")
+    agent_sub = agent.add_subparsers(dest="agent_command")
+    p = agent_sub.add_parser("providers", help="List providers.", description="List available sandbox agent providers.")
+    p.add_argument("--instance-id", help="Optional instance ID.")
+    p.set_defaults(handler=handle_agent_providers)
+    p = agent_sub.add_parser("status", help="Show provider status.", description="Show login status for one agent provider.")
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--provider", default="cursor", help="Provider ID. Example: cursor")
+    p.set_defaults(handler=handle_agent_status)
+    p = agent_sub.add_parser(
+        "login-url",
+        help="Get a provider login URL.",
+        description="Get a browser login URL for one agent provider.",
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--provider", default="cursor", help="Provider ID. Example: cursor")
+    p.set_defaults(handler=handle_agent_login_url)
+
+    p = agent_sub.add_parser(
+        "chat",
+        help="Send a prompt to the sandbox agent.",
+        description=(
+            "Send one prompt to the sandbox agent running in an instance. Use this when you want the sandbox "
+            "itself to inspect or modify the project. The automatic preview build follows the sandbox's current "
+            "branch, so run `powerbase branch switch` first when you want a feature-branch preview. By default "
+            "the command collects all streamed events and prints them as JSON. Use --stream-jsonl to print one "
+            "JSON event per line as events arrive."
+        ),
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--provider", default="cursor", help="Agent provider ID, such as cursor, opencode, or kiro.")
+    p.add_argument("--session-id", help="Optional provider session ID to resume an existing conversation.")
+    p.add_argument("--model", help="Optional model ID for providers that support explicit model selection.")
+    p.add_argument("--agent", dest="agent_name", help="Optional Kiro agent name.")
+    p.add_argument("--message", help="Prompt text. Prefix with @ to load from a file.")
+    p.add_argument("--message-file", help="Path to a file containing the prompt text.")
+    p.add_argument(
+        "--first-user-message",
+        help="Optional first user message for language alignment during auto-fix. Prefix with @ to load from a file.",
+    )
+    p.add_argument("--first-user-message-file", help="Path to a file containing the first user message.")
+    p.add_argument("--stream-jsonl", action="store_true", help="Print one JSON event per line while the chat runs.")
+    p.set_defaults(handler=handle_agent_chat)
+
+    opencode_config = agent_sub.add_parser(
+        "opencode-config",
+        help="Manage opencode API-key config.",
+        description="Read or modify the sandbox opencode auth/config files for one instance.",
+    )
+    opencode_config_sub = opencode_config.add_subparsers(dest="agent_opencode_config_command")
+    p = opencode_config_sub.add_parser(
+        "get",
+        help="Show opencode config.",
+        description="Show configured providers, custom providers, and model limit overrides for one instance.",
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.set_defaults(handler=handle_agent_opencode_config_get)
+    p = opencode_config_sub.add_parser(
+        "set",
+        help="Save one provider API key.",
+        description=(
+            "Save or update one opencode provider API key for an instance. Repeat --model-limit with JSON objects like "
+            '\'{"id":"claude-sonnet-4","limit":{"context":200000,"output":16000}}\'.'
+        ),
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--provider", required=True, help="Provider ID to configure, such as anthropic or openai.")
+    p.add_argument("--api-key", required=True, help="API key to store in the sandbox.")
+    p.add_argument(
+        "--model-limit",
+        action="append",
+        help="Optional JSON object describing one model limit override.",
+    )
+    p.set_defaults(handler=handle_agent_opencode_config_set)
+    p = opencode_config_sub.add_parser(
+        "delete",
+        help="Delete one provider API key.",
+        description="Remove one opencode provider API key from the sandbox auth file.",
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--provider", required=True, help="Provider ID to remove.")
+    p.set_defaults(handler=handle_agent_opencode_config_delete)
+
+    opencode_json = agent_sub.add_parser(
+        "opencode-json",
+        help="Replace the sandbox opencode.json file.",
+        description="Replace the sandbox opencode.json file with the contents of one local JSON document.",
+    )
+    opencode_json_sub = opencode_json.add_subparsers(dest="agent_opencode_json_command")
+    p = opencode_json_sub.add_parser(
+        "set",
+        help="Replace opencode.json.",
+        description="Load one local JSON file and replace the sandbox opencode.json file with it.",
+    )
+    p.add_argument("--instance-id", help="Instance ID. Falls back to context.json.")
+    p.add_argument("--file", required=True, help="Path to a local JSON file.")
+    p.set_defaults(handler=handle_agent_opencode_json_set)