cpsl 0.1.0__tar.gz

cpsl-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cpsl
+Version: 0.1.0
+Summary: Capsule SDK and CLI
+Requires-Python: >=3.10
+Requires-Dist: grpcio>=1.69.0
+Requires-Dist: grpclib>=0.4.7
+Requires-Dist: protobuf>=4.25.0
+Requires-Dist: betterproto-beta9==2.0.1
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0

cpsl-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "cpsl"
+version = "0.1.0"
+description = "Capsule SDK and CLI"
+requires-python = ">=3.10"
+dependencies = [
+    "grpcio>=1.69.0",
+    "grpclib>=0.4.7",
+    "protobuf>=4.25.0",
+    "betterproto-beta9==2.0.1",
+    "click>=8.1.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+capsule = "cpsl.cli.main:start"
+
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+exclude = ["src/cpsl/clients"]
+src = ["src"]

cpsl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cpsl-0.1.0/src/cpsl/__init__.py

@@ -0,0 +1 @@
+"""Capsule SDK — create and manage capsule apps."""

cpsl-0.1.0/src/cpsl/__main__.py

@@ -0,0 +1,3 @@
+from cpsl.cli.main import start
+
+start()

cpsl-0.1.0/src/cpsl/channel.py

@@ -0,0 +1,162 @@
+import functools
+from typing import Any, Callable, List, NewType, Optional, Sequence, Tuple, cast
+
+import grpc
+from grpc import ChannelCredentials
+from grpc._interceptor import _Channel as InterceptorChannel
+
+from . import terminal
+from .config import ConfigContext, get_config_context
+
+GRPC_MAX_MESSAGE_SIZE = 16 * 1024 * 1024
+
+MetadataType = NewType("MetadataType", List[Tuple[Any, Any]])
+
+
+class Channel(InterceptorChannel):
+    def __init__(
+        self,
+        addr: str,
+        token: Optional[str] = None,
+        credentials: Optional[ChannelCredentials] = None,
+        options: Optional[Sequence[Tuple[str, Any]]] = None,
+    ):
+        if options is None:
+            options = [
+                ("grpc.max_receive_message_length", GRPC_MAX_MESSAGE_SIZE),
+                ("grpc.max_send_message_length", GRPC_MAX_MESSAGE_SIZE),
+            ]
+
+        if credentials is not None:
+            channel = grpc.secure_channel(addr, credentials, options=options)
+        elif addr.endswith("443"):
+            channel = grpc.secure_channel(addr, grpc.ssl_channel_credentials(), options=options)
+        else:
+            channel = grpc.insecure_channel(addr, options=options)
+
+        interceptor = AuthTokenInterceptor(token)
+        super().__init__(channel=channel, interceptor=interceptor)
+
+
+class AuthTokenInterceptor(
+    grpc.UnaryUnaryClientInterceptor,
+    grpc.UnaryStreamClientInterceptor,
+    grpc.StreamUnaryClientInterceptor,
+    grpc.StreamStreamClientInterceptor,
+):
+    def __init__(self, token: Optional[str] = None):
+        self._token = token
+
+    def _add_auth_metadata(self, client_call_details):
+        if self._token:
+            auth_headers = [("authorization", f"Bearer {self._token}")]
+            if client_call_details.metadata is not None:
+                new_metadata = client_call_details.metadata + auth_headers
+            else:
+                new_metadata = auth_headers
+        else:
+            new_metadata = client_call_details.metadata
+
+        return client_call_details._replace(metadata=cast(MetadataType, new_metadata))
+
+    def intercept_call(self, continuation, client_call_details, request):
+        new_details = self._add_auth_metadata(client_call_details)
+        return continuation(new_details, request)
+
+    def intercept_call_stream(self, continuation, client_call_details, request_iterator):
+        return self.intercept_call(continuation, client_call_details, request=request_iterator)
+
+    intercept_unary_unary = intercept_call
+    intercept_unary_stream = intercept_call
+    intercept_stream_unary = intercept_call_stream
+    intercept_stream_stream = intercept_call_stream
+
+
+def get_channel(context: Optional[ConfigContext] = None) -> Channel:
+    if not context:
+        context = get_config_context()
+
+    if not context or not context.is_valid():
+        raise RuntimeError("No valid config. Run 'capsule login' first.")
+
+    return Channel(
+        addr=f"{context.gateway_host}:{context.gateway_port}",
+        token=context.token,
+    )
+
+
+def handle_grpc_error(error: grpc.RpcError) -> None:
+    code = error.code()
+    details = error.details()
+
+    if code == grpc.StatusCode.UNAUTHENTICATED:
+        terminal.error("Unauthorized. Run 'capsule login' to authenticate.")
+    elif code == grpc.StatusCode.UNAVAILABLE:
+        terminal.error("Unable to connect to gateway.")
+    elif code == grpc.StatusCode.CANCELLED:
+        return
+    else:
+        terminal.error(f"gRPC error: {code} — {details}")
+
+
+class ServiceClient:
+    def __init__(self, config: Optional[ConfigContext] = None) -> None:
+        self._config = config
+        self._channel: Optional[Channel] = None
+        self._stub = None
+
+    def __enter__(self) -> "ServiceClient":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    @classmethod
+    def with_channel(cls, channel: Channel) -> "ServiceClient":
+        client = cls()
+        client.channel = channel
+        return client
+
+    @property
+    def channel(self) -> Channel:
+        if not self._channel:
+            self._channel = get_channel(self._config)
+        return self._channel
+
+    @channel.setter
+    def channel(self, value: Channel) -> None:
+        if not value or not isinstance(value, Channel):
+            raise ValueError("Invalid channel")
+        self._channel = value
+
+    @property
+    def capsule(self):
+        if not self._stub:
+            from .clients.capsule import CapsuleServiceStub
+
+            self._stub = CapsuleServiceStub(self.channel)
+        return self._stub
+
+    def close(self) -> None:
+        if self._channel:
+            self._channel.close()
+
+
+def pass_service_client(func: Callable) -> Callable:
+    """Decorator that creates a ServiceClient and passes it as the first arg."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ctx = get_config_context()
+        if not ctx or not ctx.is_valid():
+            terminal.error("Not logged in. Run 'capsule login' first.")
+            raise SystemExit(1)
+
+        try:
+            with ServiceClient(ctx) as client:
+                return func(client, *args, **kwargs)
+        except grpc.RpcError as e:
+            handle_grpc_error(e)
+            raise SystemExit(1)
+
+    return wrapper

cpsl-0.1.0/src/cpsl/cli/app.py

@@ -0,0 +1,78 @@
+import click
+from rich.table import Table
+
+from .. import terminal
+from ..channel import ServiceClient, pass_service_client
+from ..clients.capsule import CreateAppRequest, GetAppRequest, ListAppsRequest
+
+
+@click.group()
+def app():
+    """Manage apps."""
+    pass
+
+
+@app.command("create")
+@click.option("--name", required=True, help="App name")
+@click.option("--price", default=100, type=int, help="Price in cents")
+@pass_service_client
+def create(client: ServiceClient, name: str, price: int):
+    """Create a new app."""
+    res = client.capsule.create_app(
+        CreateAppRequest(name=name, price_in_cents=price)
+    )
+    if not res.ok:
+        terminal.error(f"Failed: {res.err_msg}")
+        raise SystemExit(1)
+
+    terminal.success(f"Created app \"{res.app.name}\" at {res.app.hostname}.capsule.new")
+    terminal.info(f"  ID:       {res.app.id}")
+    terminal.info(f"  Hostname: {res.app.hostname}")
+    terminal.info(f"  Price:    {res.app.price_in_cents}¢")
+
+
+@app.command("list")
+@pass_service_client
+def list_apps(client: ServiceClient):
+    """List your apps."""
+    res = client.capsule.list_apps(ListAppsRequest())
+    if not res.ok:
+        terminal.error(f"Failed: {res.err_msg}")
+        raise SystemExit(1)
+
+    if not res.apps:
+        terminal.info("No apps yet. Create one with 'capsule app create'.")
+        return
+
+    from rich.console import Console
+
+    table = Table(title="Apps")
+    table.add_column("Name")
+    table.add_column("ID")
+    table.add_column("Hostname")
+    table.add_column("Price")
+    table.add_column("Created")
+
+    for a in res.apps:
+        table.add_row(a.name, a.id, a.hostname, f"{a.price_in_cents}¢", a.created_at)
+
+    Console().print(table)
+
+
+@app.command("get")
+@click.argument("app_id")
+@pass_service_client
+def get(client: ServiceClient, app_id: str):
+    """Get details of an app by ID."""
+    res = client.capsule.get_app(GetAppRequest(id=app_id))
+    if not res.ok:
+        terminal.error(f"Failed: {res.err_msg}")
+        raise SystemExit(1)
+
+    a = res.app
+    terminal.header(a.name)
+    terminal.info(f"  ID:       {a.id}")
+    terminal.info(f"  Hostname: {a.hostname}")
+    terminal.info(f"  Owner:    {a.owner_id}")
+    terminal.info(f"  Price:    {a.price_in_cents}¢")
+    terminal.info(f"  Created:  {a.created_at}")

cpsl-0.1.0/src/cpsl/cli/login.py

@@ -0,0 +1,87 @@
+import time
+import webbrowser
+
+import click
+from rich.console import Console
+from rich.spinner import Spinner
+from rich.live import Live
+
+from .. import terminal
+from ..channel import Channel, ServiceClient
+from ..clients.capsule import ConfirmLoginRequest, RequestLoginRequest
+from ..config import (
+    DEFAULT_CONTEXT_NAME,
+    ConfigContext,
+    get_settings,
+    load_config,
+    save_config,
+)
+
+POLL_INTERVAL_S = 2
+POLL_TIMEOUT_S = 300
+
+
+@click.command()
+@click.option("--host", default=None, help="Gateway host")
+@click.option("--port", default=None, type=int, help="Gateway port")
+def login(host: str | None, port: int | None):
+    """Authenticate with Capsule via browser.
+
+    Set CAPSULE_GATEWAY_URL=localhost:1980 to target a local dev server.
+    """
+    settings = get_settings()
+    gateway_host = host or settings.gateway_host
+    gateway_port = port or settings.gateway_port
+
+    channel = Channel(addr=f"{gateway_host}:{gateway_port}", token=None)
+
+    with ServiceClient.with_channel(channel) as client:
+        res = client.capsule.request_login(RequestLoginRequest())
+        if not res.ok:
+            terminal.error(f"Login failed: {res.err_msg}")
+            raise SystemExit(1)
+
+        login_url = res.login_url
+        terminal.header("Opening browser to authenticate...")
+        terminal.info(f"{login_url}\n")
+
+        if not webbrowser.open(login_url):
+            terminal.warn("Could not open browser. Open the URL above manually.")
+
+        confirm = _poll_with_spinner(client, res.login_id)
+
+    context = ConfigContext(
+        token=confirm.token,
+        gateway_host=gateway_host,
+        gateway_port=gateway_port,
+    )
+
+    contexts = load_config()
+    contexts[DEFAULT_CONTEXT_NAME] = context
+    save_config(contexts)
+
+    terminal.success(f"\nAuthenticated! Workspace: {confirm.workspace_id}")
+
+
+def _poll_with_spinner(client: ServiceClient, login_id: str):
+    console = Console()
+    deadline = time.time() + POLL_TIMEOUT_S
+
+    with Live(
+        Spinner("dots", text="Waiting for authentication in the browser..."),
+        console=console,
+        transient=True,
+    ):
+        while time.time() < deadline:
+            time.sleep(POLL_INTERVAL_S)
+
+            res = client.capsule.confirm_login(ConfirmLoginRequest(login_id=login_id))
+            if res.ok:
+                return res
+
+            if res.err_msg not in ("pending",):
+                terminal.error(f"Login failed: {res.err_msg}")
+                raise SystemExit(1)
+
+    terminal.error("Login timed out. Please try again.")
+    raise SystemExit(1)

cpsl-0.1.0/src/cpsl/cli/main.py

@@ -0,0 +1,22 @@
+import os
+
+os.environ.setdefault("GRPC_VERBOSITY", "ERROR")
+
+import click
+
+from .login import login
+from .app import app
+
+
+@click.group()
+def cli():
+    """Capsule CLI — create and manage capsule apps."""
+    pass
+
+
+cli.add_command(login)
+cli.add_command(app)
+
+
+def start():
+    cli()

cpsl-0.1.0/src/cpsl/clients/capsule/__init__.py

@@ -0,0 +1,199 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: capsule.proto
+# plugin: python-betterproto
+# This file has been @generated
+
+from dataclasses import dataclass
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+)
+
+import betterproto
+import grpc
+from betterproto.grpcstub.grpcio_client import SyncServiceStub
+from betterproto.grpcstub.grpclib_server import ServiceBase
+
+if TYPE_CHECKING:
+    import grpclib.server
+    from betterproto.grpcstub.grpclib_client import MetadataLike
+    from grpclib.metadata import Deadline
+
+
+@dataclass(eq=False, repr=False)
+class App(betterproto.Message):
+    id: str = betterproto.string_field(1)
+    name: str = betterproto.string_field(2)
+    hostname: str = betterproto.string_field(3)
+    owner_id: str = betterproto.string_field(4)
+    created_at: str = betterproto.string_field(5)
+    updated_at: str = betterproto.string_field(6)
+    price_in_cents: int = betterproto.int32_field(7)
+
+
+@dataclass(eq=False, repr=False)
+class CreateAppRequest(betterproto.Message):
+    name: str = betterproto.string_field(1)
+    hostname: str = betterproto.string_field(2)
+    price_in_cents: int = betterproto.int32_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class CreateAppResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    app: "App" = betterproto.message_field(2)
+    err_msg: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class GetAppRequest(betterproto.Message):
+    id: str = betterproto.string_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class GetAppResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    app: "App" = betterproto.message_field(2)
+    err_msg: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class ListAppsRequest(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class ListAppsResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    apps: List["App"] = betterproto.message_field(2)
+    err_msg: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class ResolveRequest(betterproto.Message):
+    hostname: str = betterproto.string_field(1)
+    access_token: str = betterproto.string_field(2)
+
+
+@dataclass(eq=False, repr=False)
+class ResolveResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    app: "App" = betterproto.message_field(2)
+    has_access: bool = betterproto.bool_field(3)
+    err_msg: str = betterproto.string_field(4)
+
+
+@dataclass(eq=False, repr=False)
+class CreateCheckoutRequest(betterproto.Message):
+    app_id: str = betterproto.string_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class CreateCheckoutResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    checkout_url: str = betterproto.string_field(2)
+    err_msg: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class AuthorizeRequest(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class AuthorizeResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    workspace_id: str = betterproto.string_field(2)
+    err_msg: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class RequestLoginRequest(betterproto.Message):
+    email: str = betterproto.string_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class RequestLoginResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    login_id: str = betterproto.string_field(2)
+    err_msg: str = betterproto.string_field(3)
+    login_url: str = betterproto.string_field(4)
+
+
+@dataclass(eq=False, repr=False)
+class ConfirmLoginRequest(betterproto.Message):
+    login_id: str = betterproto.string_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class ConfirmLoginResponse(betterproto.Message):
+    ok: bool = betterproto.bool_field(1)
+    token: str = betterproto.string_field(2)
+    workspace_id: str = betterproto.string_field(3)
+    err_msg: str = betterproto.string_field(4)
+
+
+class CapsuleServiceStub(SyncServiceStub):
+    def create_app(self, create_app_request: "CreateAppRequest") -> "CreateAppResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/CreateApp",
+            CreateAppRequest,
+            CreateAppResponse,
+        )(create_app_request)
+
+    def get_app(self, get_app_request: "GetAppRequest") -> "GetAppResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/GetApp",
+            GetAppRequest,
+            GetAppResponse,
+        )(get_app_request)
+
+    def list_apps(self, list_apps_request: "ListAppsRequest") -> "ListAppsResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/ListApps",
+            ListAppsRequest,
+            ListAppsResponse,
+        )(list_apps_request)
+
+    def resolve(self, resolve_request: "ResolveRequest") -> "ResolveResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/Resolve",
+            ResolveRequest,
+            ResolveResponse,
+        )(resolve_request)
+
+    def create_checkout(
+        self, create_checkout_request: "CreateCheckoutRequest"
+    ) -> "CreateCheckoutResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/CreateCheckout",
+            CreateCheckoutRequest,
+            CreateCheckoutResponse,
+        )(create_checkout_request)
+
+    def authorize(self, authorize_request: "AuthorizeRequest") -> "AuthorizeResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/Authorize",
+            AuthorizeRequest,
+            AuthorizeResponse,
+        )(authorize_request)
+
+    def request_login(
+        self, request_login_request: "RequestLoginRequest"
+    ) -> "RequestLoginResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/RequestLogin",
+            RequestLoginRequest,
+            RequestLoginResponse,
+        )(request_login_request)
+
+    def confirm_login(
+        self, confirm_login_request: "ConfirmLoginRequest"
+    ) -> "ConfirmLoginResponse":
+        return self._unary_unary(
+            "/capsule.CapsuleService/ConfirmLogin",
+            ConfirmLoginRequest,
+            ConfirmLoginResponse,
+        )(confirm_login_request)

cpsl-0.1.0/src/cpsl/config.py

@@ -0,0 +1,130 @@
+import configparser
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import MutableMapping, Optional, Union
+
+DEFAULT_CONTEXT_NAME = "default"
+DEFAULT_GATEWAY_HOST = "gateway.capsule.new"
+DEFAULT_GATEWAY_PORT = 443
+
+
+def _parse_gateway_url(raw: str) -> tuple[str, int]:
+    """Parse a host:port string, defaulting port to 443 if omitted."""
+    raw = raw.strip()
+    if ":" in raw:
+        host, port_s = raw.rsplit(":", 1)
+        return host, int(port_s)
+    return raw, DEFAULT_GATEWAY_PORT
+
+
+@dataclass
+class SDKSettings:
+    name: str = "Capsule"
+    gateway_host: str = DEFAULT_GATEWAY_HOST
+    gateway_port: int = DEFAULT_GATEWAY_PORT
+    config_path: Path = Path("~/.capsule/config.ini").expanduser()
+    api_token: Optional[str] = os.getenv("CAPSULE_TOKEN")
+
+    def __post_init__(self):
+        if p := os.getenv("CONFIG_PATH"):
+            self.config_path = Path(p).expanduser()
+
+        if url := os.getenv("CAPSULE_GATEWAY_URL"):
+            self.gateway_host, self.gateway_port = _parse_gateway_url(url)
+
+
+@dataclass
+class ConfigContext:
+    token: Optional[str] = None
+    gateway_host: Optional[str] = None
+    gateway_port: Optional[int] = None
+
+    def to_dict(self) -> dict:
+        return {k: ("" if not v else v) for k, v in asdict(self).items()}
+
+    def is_valid(self) -> bool:
+        return all([self.token, self.gateway_host, self.gateway_port])
+
+
+_SETTINGS: Optional[SDKSettings] = None
+
+
+def get_settings() -> SDKSettings:
+    global _SETTINGS
+    if not _SETTINGS:
+        _SETTINGS = SDKSettings()
+    return _SETTINGS
+
+
+def set_settings(s: SDKSettings) -> None:
+    global _SETTINGS
+    _SETTINGS = s
+
+
+def load_config(path: Optional[Union[str, Path]] = None) -> MutableMapping[str, ConfigContext]:
+    if path is None:
+        path = get_settings().config_path
+
+    path = Path(path)
+    if not path.exists():
+        return {}
+
+    parser = configparser.ConfigParser(default_section=DEFAULT_CONTEXT_NAME)
+    parser.read(path)
+
+    contexts: MutableMapping[str, ConfigContext] = {}
+    for name, section in parser.items():
+        port = section.get("gateway_port")
+        contexts[name] = ConfigContext(
+            token=section.get("token"),
+            gateway_host=section.get("gateway_host"),
+            gateway_port=int(port) if port else None,
+        )
+
+    return contexts
+
+
+def save_config(
+    contexts: MutableMapping[str, ConfigContext],
+    path: Optional[Union[Path, str]] = None,
+) -> None:
+    if not contexts:
+        return
+
+    if path is None:
+        path = get_settings().config_path
+
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    parser = configparser.ConfigParser(default_section=DEFAULT_CONTEXT_NAME)
+    parser.read_dict({k: v.to_dict() for k, v in contexts.items()})
+
+    with open(path, "w") as f:
+        parser.write(f)
+
+
+def is_config_empty(path: Optional[Union[Path, str]] = None) -> bool:
+    if path is None:
+        path = get_settings().config_path
+
+    path = Path(path)
+    return not path.exists()
+
+
+def get_config_context(name: str = DEFAULT_CONTEXT_NAME) -> Optional[ConfigContext]:
+    contexts = load_config()
+    if name in contexts:
+        return contexts[name]
+
+    settings = get_settings()
+    token = os.getenv("CAPSULE_TOKEN", settings.api_token)
+    if token:
+        return ConfigContext(
+            token=token,
+            gateway_host=settings.gateway_host,
+            gateway_port=settings.gateway_port,
+        )
+
+    return None

cpsl-0.1.0/src/cpsl/terminal.py

@@ -0,0 +1,24 @@
+from rich.console import Console
+
+_console = Console()
+_err_console = Console(stderr=True)
+
+
+def header(text: str) -> None:
+    _console.print(f"\n[bold]{text}[/]")
+
+
+def info(text: str) -> None:
+    _console.print(text)
+
+
+def success(text: str) -> None:
+    _console.print(f"[green]{text}[/]")
+
+
+def warn(text: str) -> None:
+    _err_console.print(f"[yellow]{text}[/]")
+
+
+def error(text: str) -> None:
+    _err_console.print(f"[red]{text}[/]")

cpsl-0.1.0/src/cpsl.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cpsl
+Version: 0.1.0
+Summary: Capsule SDK and CLI
+Requires-Python: >=3.10
+Requires-Dist: grpcio>=1.69.0
+Requires-Dist: grpclib>=0.4.7
+Requires-Dist: protobuf>=4.25.0
+Requires-Dist: betterproto-beta9==2.0.1
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0

cpsl-0.1.0/src/cpsl.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+pyproject.toml
+src/cpsl/__init__.py
+src/cpsl/__main__.py
+src/cpsl/channel.py
+src/cpsl/config.py
+src/cpsl/terminal.py
+src/cpsl.egg-info/PKG-INFO
+src/cpsl.egg-info/SOURCES.txt
+src/cpsl.egg-info/dependency_links.txt
+src/cpsl.egg-info/entry_points.txt
+src/cpsl.egg-info/requires.txt
+src/cpsl.egg-info/top_level.txt
+src/cpsl/cli/__init__.py
+src/cpsl/cli/app.py
+src/cpsl/cli/login.py
+src/cpsl/cli/main.py
+src/cpsl/clients/__init__.py
+src/cpsl/clients/capsule/__init__.py

cpsl-0.1.0/src/cpsl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cpsl-0.1.0/src/cpsl.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+capsule = cpsl.cli.main:start

cpsl-0.1.0/src/cpsl.egg-info/requires.txt

@@ -0,0 +1,6 @@
+grpcio>=1.69.0
+grpclib>=0.4.7
+protobuf>=4.25.0
+betterproto-beta9==2.0.1
+click>=8.1.0
+rich>=13.0.0

cpsl-0.1.0/src/cpsl.egg-info/top_level.txt

@@ -0,0 +1 @@
+cpsl