superwise-sentinel-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.3.1](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/compare/0.3.0...0.3.1) (2026-09-29)
+
+
+### <!-- 2. -->:bug: Bug Fixes
+
+* check gateway health before proxy on ([370105d](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/commit/370105d93431fb58f9be433624d3cf78b563591b))
+* verbose quickstart ([c46ed21](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/commit/c46ed21da9c2af55754c32efcf724f79ce38e7f4))
+* verify docker is running ([e36c3d1](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/commit/e36c3d18d585211b1b1b8e1095a298207a4710cf))
+
+## [0.3.0](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/compare/0.2.3...0.3.0) (2026-09-16)
+
+
+### <!-- 1. -->:rocket: New Features
+
+* configure codex ([16acd79](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/commit/16acd797fa82669ec3d195fbee8c50e1b4ab0055))
+
+
+### <!-- 2. -->:bug: Bug Fixes
+
+* configure sentinel-cli request timeout ([a2597b7](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/commit/a2597b742136bb5b05baa046e2a13340b75577cc))
+
 ## [0.2.3](https://gitlab.com/askboss/product/superwise/platform/sentinel-cli/compare/0.2.2...0.2.3) (2026-08-25)
 
 

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: superwise-sentinel-cli
-Version: 0.3.0
+Version: 0.4.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

superwise_sentinel_cli-0.4.0/build.env

@@ -0,0 +1 @@
+RELEASED_VERSION=0.4.0

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "superwise-sentinel-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "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 = ">=3.11, <4.0"
 dependencies = [

superwise_sentinel_cli-0.4.0/src/superwise_sentinel_cli/claude_desktop_profile.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from pathlib import Path
+
+from superwise_sentinel_cli.config import CONFIG_DIR
+from superwise_sentinel_cli.config import IS_MACOS
+from superwise_sentinel_cli.config import IS_WINDOWS
+from superwise_sentinel_cli.exceptions import ClaudeDesktopConfigError
+
+_ENTRY_NAME = "Superwise Sentinel"
+_DEFAULT_META = {"appliedId": "", "entries": []}
+
+_TOKEN_FILE = CONFIG_DIR / "claude_desktop_token"
+
+
+def _app_support_dir() -> Path:
+    if IS_WINDOWS:
+        raise ClaudeDesktopConfigError("Claude Desktop auto-configuration is not supported on Windows yet.")
+    if IS_MACOS:
+        return Path.home() / "Library" / "Application Support" / "Claude-3p"
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg_config_home) if xdg_config_home else Path.home() / ".config"
+    return base / "Claude-3p"
+
+
+def _desktop_config_path() -> Path:
+    return _app_support_dir() / "claude_desktop_config.json"
+
+
+def _config_library_dir() -> Path:
+    return _app_support_dir() / "configLibrary"
+
+
+def _meta_path() -> Path:
+    return _config_library_dir() / "_meta.json"
+
+
+def _entry_path(entry_id: str) -> Path:
+    return _config_library_dir() / f"{entry_id}.json"
+
+
+def _read_json(path: Path, default: dict) -> dict:
+    if not path.exists():
+        return default
+    try:
+        return json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ClaudeDesktopConfigError(f"Could not read {path}: {exc}") from exc
+
+
+def _write_json(path: Path, data: dict) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(data, indent=2))
+    except OSError as exc:
+        raise ClaudeDesktopConfigError(f"Could not write {path}: {exc}") from exc
+
+
+def _load_meta() -> dict:
+    return _read_json(_meta_path(), dict(_DEFAULT_META))
+
+
+def _find_entry(entries: list[dict]) -> dict | None:
+    return next((e for e in entries if e.get("name") == _ENTRY_NAME), None)
+
+
+def claude_desktop_token_cached() -> bool:
+    return _TOKEN_FILE.exists() and bool(_TOKEN_FILE.read_text().strip())
+
+
+def _get_token() -> str:
+    if claude_desktop_token_cached():
+        return _TOKEN_FILE.read_text().strip()
+
+    from superwise_sentinel_cli.claude_oauth import obtain_claude_oauth_token
+
+    token = obtain_claude_oauth_token()
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _TOKEN_FILE.write_text(token)
+    return token
+
+
+def _ensure_entry(meta: dict) -> dict:
+    entries = meta.setdefault("entries", [])
+    entry = _find_entry(entries)
+    if entry is None:
+        entry = {"id": str(uuid.uuid4()), "name": _ENTRY_NAME}
+        entries.append(entry)
+    return entry
+
+
+def _discard_entry(meta: dict, entry: dict) -> None:
+    remaining = [e for e in meta.get("entries", []) if e is not entry]
+    meta["entries"] = remaining
+    if meta.get("appliedId") == entry["id"]:
+        meta["appliedId"] = remaining[0]["id"] if remaining else ""
+    _write_json(_meta_path(), meta)
+
+    entry_path = _entry_path(entry["id"])
+    if entry_path.exists():
+        entry_path.unlink()
+
+
+def _write_entry_file(entry_id: str, base_url: str, token: str) -> None:
+    _write_json(
+        _entry_path(entry_id),
+        {
+            "inferenceGatewayBaseUrl": f"{base_url.rstrip('/')}/anthropic",
+            "inferenceGatewayApiKey": token,
+            "inferenceProvider": "gateway",
+            "inferenceCredentialKind": "static",
+        },
+    )
+
+
+def _set_deployment_mode(enabled: bool) -> bool:
+    desktop_config = _read_json(_desktop_config_path(), {})
+    if (desktop_config.get("deploymentMode") == "3p") == enabled:
+        return False
+    if enabled:
+        desktop_config["deploymentMode"] = "3p"
+    else:
+        del desktop_config["deploymentMode"]
+    _write_json(_desktop_config_path(), desktop_config)
+    return True
+
+
+def write_claude_desktop_config(base_url: str) -> None:
+    _app_support_dir()
+    token = _get_token()
+
+    meta = _load_meta()
+    entry = _ensure_entry(meta)
+    _write_entry_file(entry["id"], base_url, token)
+    meta["appliedId"] = entry["id"]
+    _write_json(_meta_path(), meta)
+
+    _set_deployment_mode(enabled=True)
+
+
+def is_claude_desktop_configured() -> bool:
+    meta = _load_meta()
+    entry = _find_entry(meta.get("entries", []))
+    return entry is not None and meta.get("appliedId") == entry["id"] and _entry_path(entry["id"]).exists()
+
+
+def remove_claude_desktop_config() -> bool:
+    meta = _load_meta()
+    entry = _find_entry(meta.get("entries", []))
+    changed = False
+
+    if entry is not None:
+        _discard_entry(meta, entry)
+        changed = True
+
+    if not meta.get("entries"):
+        changed = _set_deployment_mode(enabled=False) or changed
+
+    return changed

superwise_sentinel_cli-0.4.0/src/superwise_sentinel_cli/claude_oauth.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import fcntl
+import os
+import pty
+import re
+import select
+import shutil
+import struct
+import subprocess
+import sys
+import termios
+import time
+
+from superwise_sentinel_cli.exceptions import ClaudeDesktopConfigError
+
+_TOKEN_PATTERN = re.compile(r"sk-ant-[A-Za-z0-9_-]+")
+
+
+def _find_claude_binary() -> str:
+    claude_bin = shutil.which("claude")
+    if claude_bin is None:
+        raise ClaudeDesktopConfigError(
+            "The 'claude' CLI was not found on PATH. Install Claude Code to auto-configure Claude Desktop."
+        )
+    return claude_bin
+
+
+def _spawn_setup_token(claude_bin: str) -> tuple[subprocess.Popen, int]:
+    master_fd, slave_fd = pty.openpty()
+    # expand pty so token isn't split between lines
+    fcntl.ioctl(slave_fd, termios.TIOCSWINSZ, struct.pack("HHHH", 200, 4000, 0, 0))
+    process = subprocess.Popen(
+        [claude_bin, "setup-token"],
+        stdin=slave_fd,
+        stdout=slave_fd,
+        stderr=slave_fd,
+        close_fds=True,
+    )
+    os.close(slave_fd)
+    return process, master_fd
+
+
+def _echo_and_extract_token(chunk: bytes, output: str) -> tuple[str, str | None]:
+    text = chunk.decode("utf-8", errors="ignore")
+    sys.stdout.write(text)
+    sys.stdout.flush()
+    output += text
+    match = _TOKEN_PATTERN.search(output)
+    return output, (match.group(0) if match else None)
+
+
+def _read_token_from_pty(process: subprocess.Popen, master_fd: int, deadline: float) -> str | None:
+    output = ""
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master_fd], [], [], 1.0)
+        if master_fd not in ready:
+            if process.poll() is not None:
+                return None
+            continue
+        try:
+            chunk = os.read(master_fd, 4096)
+        except OSError:
+            return None
+        if not chunk:
+            return None
+        output, token = _echo_and_extract_token(chunk, output)
+        if token:
+            return token
+    return None
+
+
+def _terminate(process: subprocess.Popen, master_fd: int) -> None:
+    os.close(master_fd)
+    if process.poll() is None:
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+
+
+def obtain_claude_oauth_token(timeout_seconds: float = 300) -> str:
+    claude_bin = _find_claude_binary()
+    process, master_fd = _spawn_setup_token(claude_bin)
+    try:
+        token = _read_token_from_pty(process, master_fd, time.monotonic() + timeout_seconds)
+    finally:
+        _terminate(process, master_fd)
+
+    if token is None:
+        raise ClaudeDesktopConfigError("'claude setup-token' did not produce an API token.")
+    return token

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/src/superwise_sentinel_cli/cli.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import uuid
 import webbrowser
+from time import sleep
 
 import click
 import requests
@@ -13,17 +14,25 @@ from superwise_sentinel_cli.config import AppConfig
 from superwise_sentinel_cli.config import CustomProvider
 from superwise_sentinel_cli.config import VALID_APPS
 from superwise_sentinel_cli.config import VALID_PROVIDERS
+from superwise_sentinel_cli.controller import check_gateway_health
 from superwise_sentinel_cli.controller import check_invalid_apps
 from superwise_sentinel_cli.controller import check_invalid_providers
+from superwise_sentinel_cli.controller import claude_desktop_token_cached
 from superwise_sentinel_cli.controller import clear_env_vars
+from superwise_sentinel_cli.controller import diagnose_unhealthy_gateway
 from superwise_sentinel_cli.controller import get_activation_url
+from superwise_sentinel_cli.controller import get_container_state
+from superwise_sentinel_cli.controller import get_gateway_logs
+from superwise_sentinel_cli.controller import get_gateway_status
 from superwise_sentinel_cli.controller import get_proxy_status
 from superwise_sentinel_cli.controller import get_running_gateway
 from superwise_sentinel_cli.controller import get_sentinel_url
+from superwise_sentinel_cli.controller import is_docker_running
 from superwise_sentinel_cli.controller import needs_auth
 from superwise_sentinel_cli.controller import parse_apps
 from superwise_sentinel_cli.controller import parse_providers
 from superwise_sentinel_cli.controller import provision_gateway
+from superwise_sentinel_cli.controller import remove_claude_desktop_config
 from superwise_sentinel_cli.controller import remove_codex_config
 from superwise_sentinel_cli.controller import save_apps
 from superwise_sentinel_cli.controller import save_gateway_url
@@ -33,6 +42,7 @@ from superwise_sentinel_cli.controller import stop_gateway_container
 from superwise_sentinel_cli.controller import update_client_id_and_secret
 from superwise_sentinel_cli.controller import update_env_vars
 from superwise_sentinel_cli.controller import update_gateway_image
+from superwise_sentinel_cli.controller import write_claude_desktop
 from superwise_sentinel_cli.controller import write_codex_config
 from superwise_sentinel_cli.exceptions import AuthenticationError
 from superwise_sentinel_cli.exceptions import BaseCLIException
@@ -105,10 +115,20 @@ def main() -> None:
 @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?"):
+    click.echo(
+        """Welcome to SUPERWISE Sentinel!
+The Sentinel proxy routes your local LLM traffic through a secure gateway, enabling guardrails and optimizations.
+Select your gateway setup:
+A) Provide the URL for an existing gateway.
+B) Create a new gateway locally. Docker needs to be installed and running on this machine."""
+    )
+    if new_sentinel or not click.confirm("Do you have a URL for an existing gateway?"):
         ctx.invoke(start_gateway, new_sentinel=new_sentinel)
     else:
         ctx.invoke(config_url)
+    gateway_text = click.style("gateway", fg="green")
+    proxy_text = click.style("proxy", fg="yellow")
+    click.echo(f"\nWith the {gateway_text} ready, let's customize our {proxy_text} traffic routing.")
     ctx.invoke(config_providers)
     ctx.invoke(config_apps)
     ctx.invoke(start_proxy)
@@ -210,7 +230,9 @@ def start_gateway(
     force: bool,
     timeout_seconds: int | None,
 ) -> None:
-    """Bootstrap & run a local Sentinel gateway container."""
+    """Bootstrap & run a local Sentinel gateway container. Accessible only from this machine."""
+    if not is_docker_running():
+        raise click.ClickException("Docker is not responsive. Is it running?")
     cfg = AppConfig.load()
 
     if custom_providers:
@@ -223,6 +245,7 @@ def start_gateway(
         _apply_timeout(cfg, timeout_seconds)
 
     if force:
+        click.echo("Stopping existing gateway.")
         stop_gateway_container()
     else:
         running = get_running_gateway()
@@ -234,6 +257,7 @@ def start_gateway(
             )
             if not click.confirm("Stop it and start a new one?"):
                 return
+            click.echo("Stopping...")
             stop_gateway_container()
 
     if not sentinel_id and (new_sentinel or not cfg.sentinel_id):
@@ -259,13 +283,28 @@ def start_gateway(
 
     if created_name:
         click.echo(f"New sentinel '{created_name}' created. Sentinel ID: {cfg.sentinel_id}.")
+
+    click.echo(f"Gateway is starting up. This may take a few moments, please wait...")
+    sleep(3)
+    if not check_gateway_health(url):
+        click.echo("Gateway attempted to start but did not respond in a timely manner.")
+        click.echo(diagnose_unhealthy_gateway(), err=True)
+        if get_container_state() is not None and click.confirm(
+            "The container logs may be useful. Show container logs?"
+        ):
+            click.echo(get_gateway_logs() or "(no logs available)")
+        raise click.ClickException("Failed to start Sentinel gateway.")
+
+    local_notice = click.style("This gateway is local, and accessible only from this machine.", fg="cyan")
     click.echo(
-        f"Gateway running on {url} with sentinel ID: {cfg.sentinel_id}. Configuration updated to match."
+        f"Gateway created and running on {url}!"
         f"\nTo view Sentinel configuration and metrics, please visit {get_sentinel_url(cfg)}"
+        f"\n{local_notice}"
     )
     if timeout_seconds is not None:
         click.echo(f"Timeout set to {timeout_seconds} seconds.")
-    click.echo("Want to test it out? Run 'sentinel test --text \"Your text here\"' to see it in action.")
+    test_command = click.style('sentinel test --text "Your text here"', italic=True)
+    click.echo(f"\nWant to test it out? Run '{test_command}' to see it in action.")
 
 
 @gateway.command("stop")
@@ -276,6 +315,15 @@ def stop_gateway() -> None:
     click.echo(f"Gateway removed. Sentinel configuration remains available at {get_sentinel_url(cfg)}.")
 
 
+@gateway.command("logs")
+@click.option("--tail", type=int, default=50, show_default=True, help="Number of log lines to show.")
+def gateway_logs_cmd(tail: int) -> None:
+    """Show the local gateway container's logs."""
+    if get_container_state() is None:
+        raise click.ClickException("No local gateway container found.")
+    click.echo(get_gateway_logs(tail=tail) or "(no logs available)")
+
+
 @gateway.command("update")
 def update_gateway() -> None:
     """Pull the latest local gateway image."""
@@ -296,7 +344,40 @@ def update_gateway() -> None:
         click.echo("Image is up to date.")
 
 
-@main.group("config", invoke_without_command=True)
+@gateway.command("status")
+def gateway_status_cmd() -> None:
+    """Shows local gateway status, including health and version."""
+    cfg = AppConfig.load()
+    status = get_gateway_status(cfg, log=lambda msg: click.echo(click.style(msg, dim=True)))
+
+    docker_text = click.style("running", fg="green") if status.docker_running else click.style("not running", fg="red")
+    click.echo(f"Docker: {docker_text}")
+
+    if not status.url:
+        click.echo("Gateway: not configured")
+        return
+
+    health_text = click.style("healthy", fg="green") if status.healthy else click.style("unreachable", fg="red")
+    click.echo(f"Gateway: {status.url} [{health_text}]")
+
+    version_text = status.version or "unknown"
+    if status.is_latest is True:
+        version_text += click.style(" (latest)", fg="green")
+    elif status.is_latest is False:
+        version_text += click.style(" (update available, run `sentinel gateway update`)", fg="yellow")
+    click.echo(f"Version: {version_text}")
+
+    if status.sentinel_id:
+        click.echo(f"Sentinel ID: {status.sentinel_id}")
+    click.echo(f"Sentinel page: {get_sentinel_url(cfg)}")
+
+
+@main.group()
+def proxy() -> None:
+    """Toggle traffic interception."""
+
+
+@proxy.group("config", invoke_without_command=True)
 @click.option("--url", "url_value", default=None, help="Set the gateway URL non-interactively.")
 @click.option(
     "--providers",
@@ -381,17 +462,17 @@ def config_providers(set_value: str | None) -> None:
     "set_value",
     default=None,
     help='Set which apps Sentinel auto-configures, non-interactively (space-separated, e.g. "codex"; '
-    '"" disables auto-configuration).',
+    '"none" disables auto-configuration).',
 )
 def config_apps(set_value: str | None) -> None:
     """Set which apps Sentinel auto-configures to use the gateway.
 
-    Supported apps: codex
+    Supported apps: codex, claude_desktop
 
     Some applications do not rely on env vars for sentinel configuration,
     Auto-configuring an app means Sentinel edits that app's own config file to point it at the gateway,
-    instead of relying only on env vars. Use 'all' to select every supported app, or pass an empty
-    value ("") to disable auto-configuration entirely and manage each app's config yourself.
+    instead of relying only on env vars. Use 'all' to select every supported app, or 'none'
+    to disable auto-configuration entirely and manage each app's config yourself.
     """
     cfg = AppConfig.load()
     if set_value is not None:
@@ -400,7 +481,7 @@ def config_apps(set_value: str | None) -> None:
         return
     while True:
         raw = click.prompt(
-            "Choose the apps you want Sentinel to auto-configure (space separated, 'all', or empty to disable)",
+            "Choose the apps you want Sentinel to auto-configure (space separated, 'all', or 'none' to disable)",
             default=" ".join(cfg.apps),
             show_default=True,
         )
@@ -412,11 +493,6 @@ def config_apps(set_value: str | None) -> None:
         break
 
 
-@main.group()
-def proxy() -> None:
-    """Toggle traffic interception."""
-
-
 @proxy.command("on")
 @click.pass_context
 def start_proxy(ctx) -> None:
@@ -429,6 +505,13 @@ def start_proxy(ctx) -> None:
     if not cfg.providers:
         ctx.invoke(config_providers)
 
+    if not check_gateway_health(cfg.gateway_url):
+        click.echo(
+            f"Gateway at {cfg.gateway_url} did not respond in a timely manner."
+            f" Please verify it is healthy and try again."
+        )
+        return
+
     cfg = AppConfig.load()
     pairs = update_env_vars(cfg)
 
@@ -443,10 +526,27 @@ def start_proxy(ctx) -> None:
             "Run 'sentinel config providers --set \"openai ...\"' to include it.",
             err=True,
         )
-    else:
+
+    claude_desktop_eligible = "anthropic" in cfg.providers and "claude_desktop" in cfg.apps
+    if (
+        claude_desktop_eligible
+        and not claude_desktop_token_cached()
+        and not click.confirm(
+            "  Claude Desktop setup needs to open a browser to sign in to your Claude account "
+            "and store the resulting API token locally for the proxy.\n Continue?",
+            default=True,
+        )
+    ):
+        click.echo("  Claude Desktop config skipped.", err=True)
+    elif write_claude_desktop(cfg):
         click.echo(
-            "  Codex CLI config unchanged: 'codex' isn't in your configured apps. "
-            "Run 'sentinel config apps --set codex' to enable auto-configuration.",
+            "  Claude Desktop config updated to route through the gateway. Restart the app to apply.",
+            err=True,
+        )
+    elif "anthropic" not in cfg.providers:
+        click.echo(
+            "  Claude Desktop config unchanged: 'anthropic' isn't in your configured providers. "
+            "Run 'sentinel config providers --set \"anthropic ...\"' to include it.",
             err=True,
         )
 
@@ -456,10 +556,13 @@ def stop_proxy() -> None:
     """Stop traffic interception."""
     removed = clear_env_vars()
     if removed:
-        click.echo(f"Proxy off: {', '.join(removed)}", err=True)
+        click.echo(f"Proxy off: {', '.join(removed)}")
 
     if remove_codex_config():
-        click.echo("  Codex CLI config (~/.codex/config.toml) reverted.", err=True)
+        click.echo("  Codex CLI config (~/.codex/config.toml) reverted.")
+
+    if remove_claude_desktop_config():
+        click.echo("  Claude Desktop config reverted. Restart the app to apply.")
 
 
 @proxy.command("status")

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/src/superwise_sentinel_cli/config.py

@@ -37,7 +37,7 @@ _PROVIDER_CONFIG: dict[str, tuple[str, str]] = {
 
 VALID_PROVIDERS = list(_PROVIDER_CONFIG.keys())
 
-VALID_APPS = ["codex"]
+VALID_APPS = ["codex", "claude_desktop"]
 
 
 class CustomProvider(BaseModel):

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/src/superwise_sentinel_cli/controller.py

@@ -2,9 +2,16 @@ from __future__ import annotations
 
 import json
 import os
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
 
 import requests
 from superwise_sentinel_cli.auth import authenticate
+from superwise_sentinel_cli.claude_desktop_profile import claude_desktop_token_cached
+from superwise_sentinel_cli.claude_desktop_profile import is_claude_desktop_configured
+from superwise_sentinel_cli.claude_desktop_profile import remove_claude_desktop_config
+from superwise_sentinel_cli.claude_desktop_profile import write_claude_desktop_config as _write_claude_desktop_config
 from superwise_sentinel_cli.codex_profile import is_codex_configured
 from superwise_sentinel_cli.codex_profile import remove_codex_config
 from superwise_sentinel_cli.codex_profile import write_codex_config as _write_codex_config
@@ -13,7 +20,12 @@ from superwise_sentinel_cli.config import AppConfig
 from superwise_sentinel_cli.config import VALID_APPS
 from superwise_sentinel_cli.config import VALID_PROVIDERS
 from superwise_sentinel_cli.docker_manager import ensure_container_running
+from superwise_sentinel_cli.docker_manager import get_container_logs
+from superwise_sentinel_cli.docker_manager import get_container_state
 from superwise_sentinel_cli.docker_manager import get_running_gateway_info
+from superwise_sentinel_cli.docker_manager import get_running_gateway_version
+from superwise_sentinel_cli.docker_manager import is_docker_running
+from superwise_sentinel_cli.docker_manager import is_running_latest
 from superwise_sentinel_cli.docker_manager import pull_latest_image
 from superwise_sentinel_cli.docker_manager import stop_container
 from superwise_sentinel_cli.exceptions import AuthenticationError
@@ -25,6 +37,7 @@ from superwise_sentinel_cli.shell_profile import write_env_vars
 stop_gateway_container = stop_container
 update_gateway_image = pull_latest_image
 clear_env_vars = remove_env_vars
+get_gateway_logs = get_container_logs
 
 
 def check_invalid_providers(providers: list[str]) -> list[str]:
@@ -44,6 +57,8 @@ def parse_providers(providers: list[str]) -> list[str]:
 def parse_apps(apps: list[str]) -> list[str]:
     if apps == ["all"]:
         return list(VALID_APPS)
+    if apps == ["none"]:
+        return []
     return apps
 
 
@@ -149,6 +164,47 @@ def get_running_gateway() -> tuple[str, str | None] | None:
     return endpoint.base_url, sentinel_id
 
 
+@dataclass
+class GatewayStatus:
+    docker_running: bool
+    container_running: bool
+    url: str | None
+    healthy: bool
+    version: str | None
+    is_latest: bool | None
+    sentinel_id: str | None
+
+
+def get_gateway_status(cfg: AppConfig, log: Callable[[str], None] | None = None) -> GatewayStatus:
+    def _log(msg: str) -> None:
+        if log:
+            log(msg)
+
+    docker_running = is_docker_running()
+    info = get_running_gateway_info() if docker_running else None
+    if info is not None:
+        endpoint, sentinel_id = info
+        url = endpoint.base_url
+        version = get_running_gateway_version()
+        _log("Checking registry for the latest image...")
+        is_latest = is_running_latest()
+    else:
+        sentinel_id = cfg.sentinel_id
+        url = cfg.gateway_url
+        version = None
+        is_latest = None
+    healthy = check_gateway_health(url, retries=1) if url else False
+    return GatewayStatus(
+        docker_running=docker_running,
+        container_running=info is not None,
+        url=url,
+        healthy=healthy,
+        version=version,
+        is_latest=is_latest,
+        sentinel_id=sentinel_id,
+    )
+
+
 def update_env_vars(cfg: AppConfig) -> list[tuple[str, str]]:
     pairs = resolve_env_vars(cfg.providers, cfg.gateway_url)
     remove_env_vars()
@@ -156,6 +212,24 @@ def update_env_vars(cfg: AppConfig) -> list[tuple[str, str]]:
     return pairs
 
 
+def diagnose_unhealthy_gateway() -> str:
+    return f"Container state: {get_container_state() or 'unknown (container not found)'}."
+
+
+def check_gateway_health(gateway_url: str, retries: int = 3, delay_seconds: float = 1.0) -> bool:
+    url = gateway_url.rstrip("/") + "/healthz"
+    for attempt in range(retries):
+        try:
+            resp = requests.get(url, timeout=5)
+            if resp.ok:
+                return True
+        except requests.RequestException:
+            pass
+        if attempt < retries - 1:
+            time.sleep(delay_seconds)
+    return False
+
+
 def write_codex_config(cfg: AppConfig) -> bool:
     if "openai" not in cfg.providers or "codex" not in cfg.apps:
         return False
@@ -163,8 +237,15 @@ def write_codex_config(cfg: AppConfig) -> bool:
     return True
 
 
+def write_claude_desktop(cfg: AppConfig) -> bool:
+    if "anthropic" not in cfg.providers or "claude_desktop" not in cfg.apps:
+        return False
+    _write_claude_desktop_config(cfg.gateway_url)
+    return True
+
+
 _ENV_VAR_TO_PROVIDER = {env_var: provider for provider, (env_var, _) in _PROVIDER_CONFIG.items()}
-_APP_CONFIGURED_CHECKS = {"codex": is_codex_configured}
+_APP_CONFIGURED_CHECKS = {"codex": is_codex_configured, "claude_desktop": is_claude_desktop_configured}
 
 
 def get_proxy_status() -> tuple[list[str], list[str], bool]:

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/src/superwise_sentinel_cli/docker_manager.py

@@ -35,6 +35,14 @@ def _docker_client() -> docker.DockerClient:
         raise DockerUnavailableError() from exc
 
 
+def is_docker_running() -> bool:
+    try:
+        _docker_client()
+        return True
+    except DockerUnavailableError:
+        return False
+
+
 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
@@ -69,6 +77,99 @@ def get_running_gateway_info() -> tuple[ContainerEndpoint, str | None] | None:
     return _endpoint_from_container(container), _container_env(container).get("SENTINEL_ID")
 
 
+def _container_image_version(container: Container) -> str:
+    image = container.image
+    labels = image.labels or {}
+    version = labels.get("VERSION") or labels.get("org.opencontainers.image.version") or labels.get("version")
+    if version:
+        return version
+    if image.tags:
+        return image.tags[0]
+    return image.short_id.removeprefix("sha256:")
+
+
+def get_running_gateway_version() -> str | None:
+    try:
+        client = _docker_client()
+    except DockerUnavailableError:
+        return None
+    container = _running_container(client)
+    if container is None:
+        return None
+    return _container_image_version(container)
+
+
+def _local_image_digest(image) -> str | None:
+    for repo_digest in image.attrs.get("RepoDigests", []):
+        if "@" in repo_digest:
+            return repo_digest.split("@", 1)[1]
+    return None
+
+
+def _remote_latest_digest() -> str | None:
+    try:
+        result = subprocess.run(
+            [
+                "docker",
+                "buildx",
+                "imagetools",
+                "inspect",
+                f"{CONTAINER_IMAGE}:latest",
+                "--format",
+                "{{.Manifest.Digest}}",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except subprocess.TimeoutExpired:
+        return None
+    if result.returncode != 0:
+        return None
+    digest = result.stdout.strip()
+    return digest or None
+
+
+def is_running_latest() -> bool | None:
+    try:
+        client = _docker_client()
+    except DockerUnavailableError:
+        return None
+    container = _running_container(client)
+    if container is None:
+        return None
+    local_digest = _local_image_digest(container.image)
+    if local_digest is None:
+        return None
+    remote_digest = _remote_latest_digest()
+    if remote_digest is None:
+        return None
+    return local_digest == remote_digest
+
+
+def get_container_state() -> str | None:
+    try:
+        client = _docker_client()
+    except DockerUnavailableError:
+        return None
+    matches = client.containers.list(all=True, filters={"name": CONTAINER_NAME})
+    if not matches:
+        return None
+    matches[0].reload()
+    return matches[0].status
+
+
+def get_container_logs(tail: int = 50) -> str | None:
+    try:
+        client = _docker_client()
+    except DockerUnavailableError:
+        return None
+    matches = client.containers.list(all=True, filters={"name": CONTAINER_NAME})
+    if not matches:
+        return None
+    return matches[0].logs(tail=tail).decode("utf-8", errors="replace")
+
+
 def stop_container() -> None:
     client = _docker_client()
     matches = client.containers.list(all=True, filters={"name": CONTAINER_NAME})

{superwise_sentinel_cli-0.3.0 → superwise_sentinel_cli-0.4.0}/src/superwise_sentinel_cli/exceptions.py

@@ -23,3 +23,7 @@ class DockerUnavailableError(DockerError):
 
 class CodexConfigError(BaseCLIException):
     """Raised when the Codex config file cannot be read, parsed, or written."""
+
+
+class ClaudeDesktopConfigError(BaseCLIException):
+    """Raised when the Claude Desktop config cannot be read, parsed, or written."""

superwise_sentinel_cli-0.3.0/build.env

@@ -1 +0,0 @@
-RELEASED_VERSION=0.3.0