superwise-sentinel-cli 0.1.0__py3-none-any.whl

sentinel_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sentinel_cli/auth.py

@@ -0,0 +1,29 @@
+import requests
+from sentinel_cli.config import AppConfig
+from sentinel_cli.config import CONFIG_DIR
+
+_TOKEN_FILE = CONFIG_DIR / "token"
+
+
+def authenticate(
+    client_id: str | None = None,
+    client_secret: str | None = None,
+    auth_host: str | None = None,
+    force: bool = False,
+) -> str:
+    if not force and _TOKEN_FILE.exists():
+        return _TOKEN_FILE.read_text()
+
+    cfg = AppConfig.load()
+    url = (auth_host or cfg.sw_auth_host) + "/identity/resources/auth/v1/api-token"
+    headers = {"accept": "application/json", "content-type": "application/json"}
+    body = {"clientId": client_id or cfg.superwise_client_id, "secret": client_secret or cfg.superwise_client_secret}
+    response = requests.post(url, headers=headers, json=body, timeout=10)
+    if response.status_code == 401:
+        raise RuntimeError("Unauthorized.")
+    else:
+        response.raise_for_status()
+    token = response.json()["accessToken"]
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _TOKEN_FILE.write_text(token)
+    return token

sentinel_cli/cli.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import uuid
+
+import click
+from sentinel_cli.auth import authenticate
+from sentinel_cli.config import AppConfig
+from sentinel_cli.config import VALID_PROVIDERS
+from sentinel_cli.docker_manager import get_running_gateway_info
+from sentinel_cli.docker_manager import stop_container
+from sentinel_cli.runner import create_sentinel
+from sentinel_cli.runner import get_or_create_local_endpoint
+from sentinel_cli.runner import resolve_env_vars
+from sentinel_cli.shell_profile import remove_env_vars
+from sentinel_cli.shell_profile import write_env_vars
+
+
+_SECRET_PLACEHOLDER = "********"
+
+
+def _prompt_uuid(label: str, default: str | None, hide_input: bool = False) -> str | None:
+    display_default = _SECRET_PLACEHOLDER if (hide_input and default) else (default or "")
+    while True:
+        raw = click.prompt(label, default=display_default, hide_input=hide_input)
+        value = None if raw in ("", _SECRET_PLACEHOLDER) else raw
+        if value is None:
+            return default if (hide_input and raw == _SECRET_PLACEHOLDER) else None
+        try:
+            uuid.UUID(value)
+            return value
+        except ValueError:
+            click.echo(f"Invalid UUID: {value!r}. Please try again.")
+
+
+def echo_error(message: str) -> None:
+    click.echo(click.style(message, fg="red"), err=True)
+
+
+def _load_config() -> AppConfig:
+    try:
+        return AppConfig.load()
+    except RuntimeError as exc:
+        echo_error(f"Error loading config: {exc}")
+
+
+@click.group()
+@click.version_option(prog_name="superwise-sentinel-cli", help="Show the version and exit.")
+def main() -> None:
+    """Superwise Sentinel - Your AI Security and Optimization Gateway.
+
+    Sentinel is an LLM proxy that intercepts traffic, enabling you to monitor, secure, and optimize your AI usage.
+
+    This CLI tool helps you quickly set up traffic interception on this machine.
+    Default or existing values are displayed in brackets. Press Enter to accept existing or provide a new value.
+    """
+
+
+@main.command("quickstart")
+@click.option(
+    "--new-sentinel", is_flag=True, default=False, help="Create a new sentinel even if an ID is already configured."
+)
+@click.pass_context
+def quickstart_flow(ctx, new_sentinel: bool) -> None:
+    """Configure your first sentinel proxy."""
+    if new_sentinel or not click.confirm("Do you want to use an existing gateway?"):
+        ctx.invoke(start_gateway, new_sentinel=new_sentinel)
+    else:
+        ctx.invoke(config_url)
+    ctx.invoke(config_providers)
+    ctx.invoke(start_proxy)
+    click.echo(
+        "Sentinel proxy is ready to intercept traffic! Any new session you open will be protected by the Sentinel"
+    )
+
+
+@main.command("auth")
+@click.option("--advanced", is_flag=True, default=False, help="Show host override options.")
+def auth(advanced: bool) -> None:
+    """Authenticate with Superwise."""
+    cfg = AppConfig.load()
+    new_client_id = _prompt_uuid("Superwise Client ID", cfg.superwise_client_id)
+    new_client_secret = _prompt_uuid("Superwise Client Secret", cfg.superwise_client_secret, hide_input=True)
+    new_auth_host = cfg.sw_auth_host
+    new_api_host = cfg.sw_api_host
+    if advanced:
+        new_auth_host = click.prompt("SW_AUTH_HOST", default=cfg.sw_auth_host)
+        new_api_host = click.prompt("SW_API_HOST", default=cfg.sw_api_host)
+
+    credentials_changed = (
+        new_client_id != cfg.superwise_client_id
+        or new_client_secret != cfg.superwise_client_secret
+        or new_auth_host != cfg.sw_auth_host
+    )
+    if credentials_changed:
+        try:
+            authenticate(
+                force=True,
+                client_id=new_client_id,
+                client_secret=new_client_secret,
+                auth_host=new_auth_host,
+            )
+        except Exception as exc:
+            raise click.ClickException(str(exc)) from exc
+
+    cfg.superwise_client_id = new_client_id
+    cfg.superwise_client_secret = new_client_secret
+    cfg.sw_auth_host = new_auth_host
+    cfg.sw_api_host = new_api_host
+    cfg.save()
+    click.echo("Authentication successful.")
+
+
+@main.group()
+def gateway() -> None:
+    """Manage gateway deployment on this machine."""
+
+
+@gateway.command("start")
+@click.option("--sentinel-id", type=click.UUID, help="Provide preconfigured sentinel ID.")
+@click.option(
+    "--new-sentinel", is_flag=True, default=False, help="Create a new sentinel even if an ID is already configured."
+)
+@click.pass_context
+def start_gateway(ctx, sentinel_id: uuid.UUID | None, new_sentinel: bool) -> None:
+    """Bootstrap & run a local Sentinel gateway container."""
+    cfg = _load_config()
+
+    running = get_running_gateway_info()
+    if running is not None:
+        endpoint, running_sentinel_id = running
+        click.echo(
+            f"A local gateway is already running at {endpoint.base_url} "
+            f"(sentinel ID: {running_sentinel_id or 'unknown'})."
+        )
+        if not click.confirm("Stop it and start a new one?"):
+            return
+        stop_container()
+
+    if sentinel_id:
+        cfg.sentinel_id = str(sentinel_id)
+    elif new_sentinel or not cfg.sentinel_id:
+        click.echo("Creating a new sentinel.")
+        if not cfg.superwise_client_secret or not cfg.superwise_client_id:
+            click.echo("Authentication is required.")
+            ctx.invoke(auth)
+            cfg = AppConfig.load()
+        try:
+            created_id, created_name = create_sentinel(cfg)
+            cfg.sentinel_id = created_id
+            click.echo(f"New sentinel '{created_name}' created. Sentinel ID: {cfg.sentinel_id}")
+        except Exception as exc:
+            raise click.ClickException(str(exc)) from exc
+
+    url = get_or_create_local_endpoint(cfg)
+    cfg.gateway_url = url
+    cfg.save()
+    click.echo(f"Gateway running on {url} with sentinel ID: {cfg.sentinel_id}. Configuration updated to match.")
+
+
+@gateway.command("stop")
+def stop_gateway() -> None:
+    """Stop and remove the local gateway container."""
+    try:
+        stop_container()
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo("Gateway removed.")
+
+
+@main.group("config")
+def config() -> None:
+    """Configure gateway URL and LLM providers."""
+
+
+@config.command("url")
+def config_url() -> None:
+    """Set the gateway URL."""
+    cfg = AppConfig.load()
+    cfg.gateway_url = click.prompt("Gateway url", default=cfg.gateway_url)
+    cfg.save()
+
+
+@config.command("providers")
+def config_providers() -> None:
+    """Set the LLM providers to intercept. Use 'all' to select all supported providers."""
+    cfg = AppConfig.load()
+    while True:
+        providers = click.prompt("Providers (space separated)", default=" ".join(cfg.providers)).split()
+        if providers == ["all"]:
+            providers = VALID_PROVIDERS
+        invalid = [p for p in providers if p not in VALID_PROVIDERS]
+        if invalid:
+            echo_error(f"Unknown provider(s): {', '.join(invalid)}")
+            echo_error(f"Valid choices: {', '.join(VALID_PROVIDERS)}")
+            continue
+        break
+    cfg.providers = providers
+    cfg.save()
+
+
+@main.group()
+def proxy() -> None:
+    """Toggle traffic interception."""
+
+
+@proxy.command("on")
+@click.pass_context
+def start_proxy(ctx) -> None:
+    """Start traffic interception to configured providers.
+
+    Changes apply to new shell sessions."""
+    cfg = AppConfig.load()
+
+    if not cfg.gateway_url:
+        ctx.invoke(config_url)
+    if not cfg.providers:
+        ctx.invoke(config_providers)
+
+    pairs = resolve_env_vars(cfg.providers, cfg.gateway_url)
+    remove_env_vars()
+    write_env_vars(pairs)
+
+    for var, u in pairs:
+        click.echo(f"  {var}={u}", err=True)
+
+
+@proxy.command("off")
+def stop_proxy() -> None:
+    """Stop traffic interception."""
+    removed = remove_env_vars()
+    if removed:
+        click.echo(f"Proxy off: {', '.join(removed)}", err=True)

sentinel_cli/config.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import uuid
+from pathlib import Path
+from typing import Any
+from typing import Literal
+
+from pydantic import field_validator
+from pydantic.fields import FieldInfo
+from pydantic_settings import BaseSettings
+from pydantic_settings import PydanticBaseSettingsSource
+from pydantic_settings import SettingsConfigDict
+
+IS_WINDOWS = platform.system() == "Windows"
+IS_MACOS = platform.system() == "Darwin"
+
+if IS_WINDOWS:
+    CONFIG_DIR = Path(os.environ.get("APPDATA", Path.home())) / "sentinel"
+else:
+    CONFIG_DIR = Path.home() / ".config" / "sentinel"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+_PROVIDER_CONFIG: dict[str, tuple[str, str]] = {
+    "anthropic": ("ANTHROPIC_BASE_URL", "anthropic"),
+    "openai": ("OPENAI_BASE_URL", "openai"),
+    "google": ("GOOGLE_API_ENDPOINT", "google"),
+}
+
+VALID_PROVIDERS = list(_PROVIDER_CONFIG.keys())
+
+
+class _JsonFileSource(PydanticBaseSettingsSource):
+    """Settings source that reads from the JSON config file on disk."""
+
+    def _read(self) -> dict[str, Any]:
+        if not CONFIG_FILE.exists():
+            return {}
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, ValueError) as exc:
+            raise RuntimeError(f"Malformed config at {CONFIG_FILE}: {exc}") from exc
+
+    def get_field_value(self, field: FieldInfo, field_name: str) -> tuple[Any, str, bool]:
+        return self._read().get(field_name), field_name, False
+
+    def __call__(self) -> dict[str, Any]:
+        return self._read()
+
+
+class AppConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="SENTINEL_",
+        env_ignore_empty=True,
+        validate_assignment=True,
+    )
+
+    gateway_url: str | None = None
+    superwise_client_id: str | None = None
+    superwise_client_secret: str | None = None
+    sentinel_id: str | None = None
+    providers: list[str] = VALID_PROVIDERS
+    sw_api_host: str = "https://api.superwise.ai"
+    sw_auth_host: str = "https://authentication.superwise.ai"
+
+    @field_validator("sentinel_id", "superwise_client_id", "superwise_client_secret")
+    @classmethod
+    def must_be_uuid(cls, v: str | None) -> str | None:
+        if v is None:
+            return v
+        try:
+            uuid.UUID(v)
+        except ValueError:
+            raise ValueError(f"must be a valid UUID, got: {v!r}")
+        return v
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        # env vars override the JSON file; both override field defaults.
+        return init_settings, env_settings, _JsonFileSource(settings_cls)
+
+    def save(self) -> None:
+        """Persist configuration to disk, creating the directory if absent."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(self.model_dump_json(indent=2))
+
+    @classmethod
+    def load(cls) -> "AppConfig":
+        """Instantiate from all sources (env vars > JSON file > defaults)."""
+        try:
+            return cls()
+        except RuntimeError:
+            raise
+        except Exception as exc:
+            raise RuntimeError(f"Failed to load config: {exc}") from exc

sentinel_cli/docker_manager.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+import click
+import docker.errors
+from docker.models.containers import Container
+
+CONTAINER_IMAGE = "us-central1-docker.pkg.dev/admina33d6818/docker/platform/sentinel:2635076005"
+CONTAINER_NAME = "sentinel-local"
+CONTAINER_PORT = 8000
+
+
+@dataclass(frozen=True)
+class ContainerEndpoint:
+    host: str
+    port: int
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self.host}:{self.port}"
+
+
+def _docker_client() -> docker.DockerClient:
+    try:
+        client = docker.from_env()
+        client.ping()
+        return client
+    except docker.errors.DockerException as exc:
+        raise RuntimeError("Cannot connect to Docker daemon — is Docker running?") from exc
+
+
+def _running_container(client: docker.DockerClient) -> Container | None:
+    matches = client.containers.list(filters={"name": CONTAINER_NAME, "status": "running"})
+    return matches[0] if matches else None
+
+
+def _container_env(container: Container) -> dict[str, str]:
+    container.reload()
+    return dict(pair.split("=", 1) for pair in container.attrs["Config"]["Env"] if "=" in pair)
+
+
+def _endpoint_from_container(container: Container) -> ContainerEndpoint:
+    container.reload()
+    binding = container.ports.get(f"{CONTAINER_PORT}/tcp")
+    if binding:
+        host = binding[0]["HostIp"] or "127.0.0.1"
+        host = "127.0.0.1" if host in ("0.0.0.0", "") else host
+        return ContainerEndpoint(host=host, port=int(binding[0]["HostPort"]))
+
+    # No published port — use the container's bridge network IP directly.
+    ip = container.attrs["NetworkSettings"].get("IPAddress") or "127.0.0.1"
+    return ContainerEndpoint(host=ip, port=CONTAINER_PORT)
+
+
+def get_running_gateway_info() -> tuple[ContainerEndpoint, str | None] | None:
+    """Return (endpoint, sentinel_id) if the local container is running, else None."""
+    try:
+        client = _docker_client()
+    except RuntimeError:
+        return None
+    container = _running_container(client)
+    if container is None:
+        return None
+    return _endpoint_from_container(container), _container_env(container).get("SENTINEL_ID")
+
+
+def stop_container() -> None:
+    """Stop and remove the sentinel container. Returns True if it was running."""
+    client = _docker_client()
+    matches = client.containers.list(all=True, filters={"name": CONTAINER_NAME})
+    for container in matches:
+        container.stop(timeout=5)
+        container.remove(force=True)
+
+
+def _docker_pull(platform: str | None = None) -> subprocess.CompletedProcess:
+    cmd = ["docker", "pull"]
+    if platform:
+        cmd += ["--platform", platform]
+    cmd.append(CONTAINER_IMAGE)
+    return subprocess.run(cmd, stderr=subprocess.PIPE, text=True)
+
+
+def _pull_image_if_needed() -> str | None:
+    """Pull CONTAINER_IMAGE if not present locally. Returns the platform override if amd64 fallback was needed."""
+    client = _docker_client()
+    try:
+        client.images.get(CONTAINER_IMAGE)
+        return None
+    except docker.errors.ImageNotFound:
+        pass
+
+    click.echo(f"Pulling sentinel image...")
+    native = _docker_pull()
+    if native.returncode == 0:
+        return None
+
+    if "no matching manifest" in native.stderr:
+        click.echo("Native platform image not available, falling back to linux/amd64...")
+        fallback = _docker_pull("linux/amd64")
+        if fallback.returncode == 0:
+            return "linux/amd64"
+        raise RuntimeError(f"Failed to pull image {CONTAINER_IMAGE}:\n{fallback.stderr}") from None
+
+    raise RuntimeError(f"Failed to pull image {CONTAINER_IMAGE}:\n{native.stderr}") from None
+
+
+def ensure_container_running(environment: dict[str, str] | None = None) -> ContainerEndpoint:
+    """Return the endpoint of the local container, starting it if needed."""
+    client = _docker_client()
+
+    existing = _running_container(client)
+    if existing:
+        current_env = _container_env(existing)
+        requested_env = environment or {}
+        if all(current_env.get(k) == v for k, v in requested_env.items()):
+            return _endpoint_from_container(existing)
+        click.echo("Sentinel config changed, reloading container...")
+        existing.stop(timeout=5)
+        existing.remove()
+
+    for container in client.containers.list(all=True, filters={"name": CONTAINER_NAME}):
+        container.remove()
+
+    platform = _pull_image_if_needed()
+
+    try:
+        container: Container = client.containers.run(
+            CONTAINER_IMAGE,
+            name=CONTAINER_NAME,
+            ports={f"{CONTAINER_PORT}/tcp": None},
+            environment=environment or {},
+            **({} if platform is None else {"platform": platform}),
+            detach=True,
+            remove=False,
+        )
+    except docker.errors.APIError as exc:
+        raise RuntimeError(f"Failed to start sentinel container: {exc.explanation}") from exc
+
+    return _endpoint_from_container(container)

sentinel_cli/runner.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import requests
+from sentinel_cli.auth import authenticate
+from sentinel_cli.config import _PROVIDER_CONFIG
+from sentinel_cli.config import AppConfig
+from sentinel_cli.docker_manager import ensure_container_running
+
+
+def _post_sentinel(cfg: AppConfig, token: str) -> requests.Response:
+    return requests.post(
+        cfg.sw_api_host + "/v1/sentinels",
+        headers={
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {token}",
+        },
+        json={},
+    )
+
+
+def create_sentinel(cfg: AppConfig) -> tuple[str, str]:
+    response = _post_sentinel(cfg, authenticate())
+    if response.status_code == 401:
+        response = _post_sentinel(cfg, authenticate(force=True))
+    response.raise_for_status()
+    response_json = response.json()
+    return response_json["id"], response_json["name"]
+
+
+def get_or_create_local_endpoint(config: AppConfig) -> str:
+    env = {
+        "SENTINEL_ID": config.sentinel_id or "",
+        "SW_CLIENT_ID": config.superwise_client_id or "",
+        "SW_CLIENT_SECRET": config.superwise_client_secret or "",
+    }
+    if config.sw_api_host:
+        env["SW_API_HOST"] = config.sw_api_host
+    if config.sw_auth_host:
+        env["SW_AUTH_HOST"] = config.sw_auth_host
+    endpoint = ensure_container_running(environment=env)
+    return endpoint.base_url
+
+
+def resolve_env_vars(providers: list[str], base_url: str) -> list[tuple[str, str]]:
+    results: list[tuple[str, str]] = []
+
+    for provider in providers:
+        env_var, path = _PROVIDER_CONFIG[provider]
+        results.append((env_var, f"{base_url}/{path}"))
+
+    return results

sentinel_cli/shell_profile.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from sentinel_cli.config import CONFIG_DIR
+from sentinel_cli.config import IS_MACOS
+from sentinel_cli.config import IS_WINDOWS
+
+_STATE_FILE = CONFIG_DIR / "protected_vars.json"
+_SOURCE_MARKER = "# sentinel-env"
+
+
+@dataclass(frozen=True)
+class ShellContext:
+    env_file: Path
+    profile_file: Path
+    source_line: str
+
+    def export_stmt(self, var: str, url: str) -> str:
+        raise NotImplementedError
+
+    def unset_stmt(self, var: str) -> str:
+        raise NotImplementedError
+
+    @staticmethod
+    def get_platform_context() -> ShellContext:
+        if IS_WINDOWS:
+            env_file = CONFIG_DIR / "env.ps1"
+            profile_file = (
+                Path(os.environ.get("USERPROFILE", Path.home()))
+                / "Documents"
+                / "WindowsPowerShell"
+                / "Microsoft.PowerShell_profile.ps1"
+            )
+            source_line = f"{_SOURCE_MARKER}\nif (Test-Path '{env_file}') {{ . '{env_file}' }}"
+            return _WindowsShellContext(env_file=env_file, profile_file=profile_file, source_line=source_line)
+
+        env_file = CONFIG_DIR / "env.sh"
+        shell = os.environ.get("SHELL", "")
+        profile_file = Path.home() / (".bashrc" if "bash" in shell else ".zshrc")
+        source_line = f"{_SOURCE_MARKER}\n[ -f '{env_file}' ] && . '{env_file}'"
+        return _UnixShellContext(env_file=env_file, profile_file=profile_file, source_line=source_line)
+
+
+@dataclass(frozen=True)
+class _WindowsShellContext(ShellContext):
+    def export_stmt(self, var: str, url: str) -> str:
+        return f'$env:{var} = "{url}"'
+
+    def unset_stmt(self, var: str) -> str:
+        return f"Remove-Item Env:{var}"
+
+
+@dataclass(frozen=True)
+class _UnixShellContext(ShellContext):
+    def export_stmt(self, var: str, url: str) -> str:
+        return f"export {var}='{url}'"
+
+    def unset_stmt(self, var: str) -> str:
+        return f"unset {var}"
+
+
+SHELL = ShellContext.get_platform_context()
+
+
+def _ensure_profile_sources_env() -> None:
+    SHELL.profile_file.parent.mkdir(parents=True, exist_ok=True)
+    text = SHELL.profile_file.read_text() if SHELL.profile_file.exists() else ""
+    if _SOURCE_MARKER not in text:
+        SHELL.profile_file.write_text(text.rstrip("\n") + f"\n\n{SHELL.source_line}\n")
+
+
+def _launchctl(action: str, var: str, value: str = "") -> None:
+    if not IS_MACOS:
+        return
+    args = ["launchctl", action, var]
+    if value:
+        args.append(value)
+    subprocess.run(args, check=False)
+
+
+def read_env_vars() -> list[tuple[str, str]]:
+    if not _STATE_FILE.exists():
+        return []
+    try:
+        return list(json.loads(_STATE_FILE.read_text()).items())
+    except (json.JSONDecodeError, ValueError):
+        return []
+
+
+def write_env_vars(pairs: list[tuple[str, str]]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _STATE_FILE.write_text(json.dumps(dict(pairs), indent=2))
+
+    env_lines = "\n".join(SHELL.export_stmt(var, url) for var, url in pairs)
+    SHELL.env_file.write_text(env_lines + "\n")
+
+    _ensure_profile_sources_env()
+
+    for var, url in pairs:
+        _launchctl("setenv", var, url)
+
+
+def remove_env_vars() -> list[str]:
+    vars_removed = [var for var, _ in read_env_vars()]
+    for var in vars_removed:
+        _launchctl("unsetenv", var)
+    if _STATE_FILE.exists():
+        _STATE_FILE.unlink()
+    if SHELL.env_file.exists():
+        SHELL.env_file.unlink()
+    return vars_removed

sentinel_cli/test_questionary.py

@@ -0,0 +1,8 @@
+def raising():
+    print("raising")
+    raise RuntimeError("Cannot connect to Docker daemon — is Docker running?")
+
+try:
+    raising()
+except Exception as e:
+    print(e)

superwise_sentinel_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: superwise-sentinel-cli
+Version: 0.1.0
+Summary: Sentinel is an LLM proxy that intercepts traffic, enabling you to monitor, secure, and optimize your AI usage. This CLI tool helps you quickly set up traffic interception on this machine
+Requires-Python: <4.0,>=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: docker>=7.0
+Requires-Dist: pydantic-settings>=2.3
+Requires-Dist: pydantic>=2.0

superwise_sentinel_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+sentinel_cli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+sentinel_cli/auth.py,sha256=4rGPeN5RlLw12ooRv4jfgwilIFXs3Ie04R1QB1GKArc,1035
+sentinel_cli/cli.py,sha256=GFLrTNWX5CtB820J169dYekemEMY7pgmjjnS0aiG5hs,7895
+sentinel_cli/config.py,sha256=U6WqLApb-_wXv-LNwEkPvPuUxeyX-BEpkHJ7-4avPpY,3479
+sentinel_cli/docker_manager.py,sha256=gvU9HQ_VsLtAHLBGcNhfAwwD3Vrin1aFHzHLV3H29LE,4964
+sentinel_cli/runner.py,sha256=7EpEvtwrwOpVlyTXmIPgobwaZNQsc0LOrkTWUGQ38rA,1690
+sentinel_cli/shell_profile.py,sha256=PrPk3W79EVOjljmVG88C61XKsV5Dv44eNR68rvRFEGc,3546
+sentinel_cli/test_questionary.py,sha256=72CbzX7P_U3fhNWOH3EVALTc3i7Ar2zCD5b7zDSOajY,172
+superwise_sentinel_cli-0.1.0.dist-info/METADATA,sha256=p0Cl2Xh7cd8J7TLi9Sbfhm-Zb_ynoLjKmReCj0HHtc4,411
+superwise_sentinel_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+superwise_sentinel_cli-0.1.0.dist-info/entry_points.txt,sha256=kiePIAd98HyQLsl0gWBZ4a_AmDFB2bXZyx_OuXqejAs,61
+superwise_sentinel_cli-0.1.0.dist-info/RECORD,,

superwise_sentinel_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

superwise_sentinel_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sentinel = superwise_sentinel_cli.cli:main