asp-cli 0.1.0__tar.gz

asp_cli-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environment
+.venv/
+
+# Django
+*.sqlite3
+media/
+staticfiles/
+
+# Environment
+.env
+.env.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Node
+node_modules/
+
+# Local git worktrees
+.worktrees/
+/asf-doc/
+/asp-marketplace/
+
+# OS
+.DS_Store
+Thumbs.db
+
+.claude/*
+.asp/

asp_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agentic SOC Platform contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asp_cli-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: asp-cli
+Version: 0.1.0
+Summary: Command line client for Agentic SOC Platform
+Project-URL: Homepage, https://github.com/FunnyWolf/agentic-soc-platform
+Project-URL: Repository, https://github.com/FunnyWolf/agentic-soc-platform
+Project-URL: Issues, https://github.com/FunnyWolf/agentic-soc-platform/issues
+Author: Agentic SOC Platform contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agentic-soc,cli,security,soc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jmespath>=1.0.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: rich>=14.2.0
+Requires-Dist: typer>=0.20.0
+Description-Content-Type: text/markdown
+
+# ASP CLI
+
+Command line client for Agentic SOC Platform.
+
+`asp-cli` provides the `asp` command for SOC analysts and automation agents to authenticate with an ASP server, inspect cases and alerts, add comments, upload files, run playbooks, and query investigation integrations.
+
+## Install
+
+```powershell
+pipx install asp-cli
+```
+
+## Quick start
+
+```powershell
+asp auth login --api-url https://asp.example.com --api-key asp_xxx
+asp doctor
+asp case list
+```
+
+For automation and agent skills, prefer stable JSON output:
+
+```powershell
+asp case list --output json
+```

asp_cli-0.1.0/README.md

@@ -0,0 +1,25 @@
+# ASP CLI
+
+Command line client for Agentic SOC Platform.
+
+`asp-cli` provides the `asp` command for SOC analysts and automation agents to authenticate with an ASP server, inspect cases and alerts, add comments, upload files, run playbooks, and query investigation integrations.
+
+## Install
+
+```powershell
+pipx install asp-cli
+```
+
+## Quick start
+
+```powershell
+asp auth login --api-url https://asp.example.com --api-key asp_xxx
+asp doctor
+asp case list
+```
+
+For automation and agent skills, prefer stable JSON output:
+
+```powershell
+asp case list --output json
+```

asp_cli-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "asp-cli"
+version = "0.1.0"
+description = "Command line client for Agentic SOC Platform"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+    { name = "Agentic SOC Platform contributors" },
+]
+keywords = ["agentic-soc", "soc", "security", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Information Technology",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security",
+]
+dependencies = [
+    "httpx>=0.28.1",
+    "jmespath>=1.0.1",
+    "pydantic>=2.13.4",
+    "rich>=14.2.0",
+    "typer>=0.20.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/FunnyWolf/agentic-soc-platform"
+Repository = "https://github.com/FunnyWolf/agentic-soc-platform"
+Issues = "https://github.com/FunnyWolf/agentic-soc-platform/issues"
+
+[project.scripts]
+asp = "asp_cli.main:run"
+
+[build-system]
+requires = ["hatchling>=1.28"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/asp_cli"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/asp_cli/spec/operations.json" = "asp_cli/spec/operations.json"

asp_cli-0.1.0/src/asp_cli/__init__.py

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

asp_cli-0.1.0/src/asp_cli/api_client.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import httpx
+from rich.console import Console
+
+from . import __version__
+from .config import redact_secret
+from .errors import (
+    CliError,
+    EXIT_AUTH,
+    EXIT_NETWORK,
+    EXIT_NOT_FOUND,
+    EXIT_PERMISSION,
+    EXIT_SERVER,
+    EXIT_USAGE,
+)
+
+
+class AspClient:
+    def __init__(
+        self,
+        *,
+        api_url: str,
+        api_key: str | None = None,
+        verbose: bool = False,
+        console: Console | None = None,
+        timeout: float = 20.0,
+    ) -> None:
+        self.base_url = _normalize_base_url(api_url)
+        self.api_key = api_key
+        self.verbose = verbose
+        self.console = console or Console(stderr=True)
+        self.timeout = timeout
+
+    def health(self) -> dict[str, Any]:
+        return self.request("GET", "/api/health/", authenticated=False)
+
+    def version(self) -> dict[str, Any]:
+        return self.request("GET", "/api/agent/v1/version/")
+
+    def request(self, method: str, path: str, *, authenticated: bool = True, json: Any = None, files: Any = None) -> dict[str, Any]:
+        if authenticated and not self.api_key:
+            raise CliError("missing_api_key", "API key is required", {}, EXIT_AUTH)
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": f"asp-cli/{__version__}",
+        }
+        if authenticated and self.api_key:
+            headers["Authorization"] = f"Api-Key {self.api_key}"
+
+        url = f"{self.base_url}{path}"
+        started = time.perf_counter()
+        try:
+            response = httpx.request(method, url, headers=headers, json=json, files=files, timeout=self.timeout)
+        except httpx.HTTPError as exc:
+            raise CliError("network_error", f"Unable to reach ASP server: {exc}", {"url": _redact_url(url)}, EXIT_NETWORK) from exc
+
+        elapsed_ms = int((time.perf_counter() - started) * 1000)
+        if self.verbose:
+            self.console.print(f"{method} {path} -> {response.status_code} ({elapsed_ms}ms)", style="dim")
+
+        if response.status_code >= 400:
+            self._raise_http_error(response, path)
+
+        if not response.content:
+            return {}
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise CliError("invalid_response", "Server returned non-JSON response", {"status_code": response.status_code}, EXIT_SERVER) from exc
+        if not isinstance(payload, dict):
+            raise CliError("invalid_response", "Server response must be a JSON object", {"status_code": response.status_code}, EXIT_SERVER)
+        return payload
+
+    def _raise_http_error(self, response: httpx.Response, path: str) -> None:
+        message = _response_message(response)
+        details = {"status_code": response.status_code, "path": path}
+        if response.status_code == 400:
+            raise CliError("bad_request", message, details, EXIT_USAGE)
+        if response.status_code == 401:
+            raise CliError("authentication_failed", message, details, EXIT_AUTH)
+        if response.status_code == 403:
+            raise CliError("permission_denied", message, details, EXIT_PERMISSION)
+        if response.status_code == 404:
+            raise CliError("not_found", message, details, EXIT_NOT_FOUND)
+        raise CliError("server_error", message, details, EXIT_SERVER)
+
+
+def _normalize_base_url(api_url: str) -> str:
+    base = api_url.strip().rstrip("/")
+    if base.endswith("/api"):
+        base = base[:-4]
+    if not base:
+        raise CliError("missing_api_url", "ASP API URL is required", {}, EXIT_USAGE)
+    return base
+
+
+def _response_message(response: httpx.Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        return response.text.strip() or f"HTTP {response.status_code}"
+    if isinstance(payload, dict):
+        detail = payload.get("detail")
+        if isinstance(detail, str):
+            return detail
+        error = payload.get("error")
+        if isinstance(error, dict) and isinstance(error.get("message"), str):
+            return error["message"]
+    return f"HTTP {response.status_code}"
+
+
+def _redact_url(url: str) -> str:
+    return url.replace(redact_secret(url), "****") if "asp_" in url else url

asp_cli-0.1.0/src/asp_cli/config.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .errors import CliError, EXIT_CONFIG
+
+GLOBAL_SETTINGS_PATH = Path.home() / ".asp" / "settings.json"
+LOCAL_SETTINGS_DIR = ".asp"
+SETTINGS_FILENAME = "settings.json"
+SUPPORTED_KEYS = {"api_url", "api_key"}
+
+
+@dataclass(frozen=True)
+class ResolvedConfig:
+    api_url: str | None
+    api_key: str | None
+    sources: dict[str, str]
+    global_path: Path
+    local_path: Path | None
+
+    @property
+    def has_auth(self) -> bool:
+        return bool(self.api_url and self.api_key)
+
+
+def resolve_config(*, cwd: Path | None = None, api_url: str | None = None, api_key: str | None = None) -> ResolvedConfig:
+    cwd = (cwd or Path.cwd()).resolve()
+    global_settings = read_settings(GLOBAL_SETTINGS_PATH)
+    local_path = find_local_settings(cwd)
+    local_settings = read_settings(local_path) if local_path else {}
+    values: dict[str, Any] = {}
+    sources: dict[str, str] = {}
+
+    _merge(values, sources, global_settings, "global")
+    if local_path:
+        _merge(values, sources, local_settings, "local")
+    _merge(
+        values,
+        sources,
+        {
+            "api_url": os.environ.get("ASP_API_URL"),
+            "api_key": os.environ.get("ASP_API_KEY"),
+        },
+        "env",
+    )
+    _merge(values, sources, {"api_url": api_url, "api_key": api_key}, "flags")
+
+    return ResolvedConfig(
+        api_url=_clean(values.get("api_url")),
+        api_key=_clean(values.get("api_key")),
+        sources=sources,
+        global_path=GLOBAL_SETTINGS_PATH,
+        local_path=local_path,
+    )
+
+
+def auth_settings_path(*, local: bool, cwd: Path | None = None) -> Path:
+    if local:
+        return (cwd or Path.cwd()).resolve() / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+    return GLOBAL_SETTINGS_PATH
+
+
+def save_auth(*, api_url: str, api_key: str, local: bool = False, cwd: Path | None = None) -> Path:
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings["api_url"] = api_url.rstrip("/")
+    settings["api_key"] = api_key
+    write_settings(path, settings)
+    return path
+
+
+def clear_auth(*, local: bool = False, cwd: Path | None = None) -> Path:
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings.pop("api_url", None)
+    settings.pop("api_key", None)
+    write_settings(path, settings)
+    return path
+
+
+def set_config_value(key: str, value: str, *, local: bool = False, cwd: Path | None = None) -> Path:
+    if key not in SUPPORTED_KEYS:
+        raise CliError("invalid_config_key", f"Unsupported config key: {key}", {"supported": sorted(SUPPORTED_KEYS)}, EXIT_CONFIG)
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings[key] = value.rstrip("/") if key == "api_url" else value
+    write_settings(path, settings)
+    return path
+
+
+def get_config_value(key: str, *, cwd: Path | None = None, api_url: str | None = None, api_key: str | None = None) -> tuple[str | None, str | None]:
+    if key not in SUPPORTED_KEYS:
+        raise CliError("invalid_config_key", f"Unsupported config key: {key}", {"supported": sorted(SUPPORTED_KEYS)}, EXIT_CONFIG)
+    config = resolve_config(cwd=cwd, api_url=api_url, api_key=api_key)
+    return getattr(config, key), config.sources.get(key)
+
+
+def read_settings(path: Path | None) -> dict[str, Any]:
+    if path is None or not path.exists():
+        return {}
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            payload = json.load(handle)
+    except json.JSONDecodeError as exc:
+        raise CliError("invalid_config", f"Invalid JSON in settings file: {path}", {"path": str(path)}, EXIT_CONFIG) from exc
+    if not isinstance(payload, dict):
+        raise CliError("invalid_config", f"Settings file must contain a JSON object: {path}", {"path": str(path)}, EXIT_CONFIG)
+    return payload
+
+
+def write_settings(path: Path, settings: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(settings, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+    _restrict_permissions(path)
+
+
+def find_local_settings(cwd: Path) -> Path | None:
+    git_root = find_git_root(cwd)
+    if git_root is None:
+        candidate = cwd / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+        return candidate if candidate.exists() else None
+
+    current = cwd
+    while True:
+        candidate = current / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+        if candidate.exists():
+            return candidate
+        if current == git_root:
+            return None
+        current = current.parent
+
+
+def find_git_root(cwd: Path) -> Path | None:
+    current = cwd
+    while True:
+        if (current / ".git").exists():
+            return current
+        if current == current.parent:
+            return None
+        current = current.parent
+
+
+def redact_secret(value: str | None) -> str:
+    if not value:
+        return ""
+    if len(value) <= 8:
+        return "****"
+    return f"{value[:4]}...{value[-4:]}"
+
+
+def _merge(values: dict[str, Any], sources: dict[str, str], incoming: dict[str, Any], source: str) -> None:
+    for key in SUPPORTED_KEYS:
+        value = _clean(incoming.get(key))
+        if value:
+            values[key] = value
+            sources[key] = source
+
+
+def _clean(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _restrict_permissions(path: Path) -> None:
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        return

asp_cli-0.1.0/src/asp_cli/errors.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+EXIT_USAGE = 2
+EXIT_CONFIG = 3
+EXIT_AUTH = 4
+EXIT_PERMISSION = 5
+EXIT_NOT_FOUND = 6
+EXIT_CONFLICT = 7
+EXIT_VERSION = 8
+EXIT_NETWORK = 70
+EXIT_SERVER = 75
+
+
+@dataclass
+class CliError(Exception):
+    code: str
+    message: str
+    details: dict[str, Any] = field(default_factory=dict)
+    exit_code: int = EXIT_USAGE
+
+    def __str__(self) -> str:
+        return self.message