apisec-code-bolt 0.1.0__py3-none-any.whl

apisec_code_bolt/cloud/__init__.py

@@ -0,0 +1 @@
+"""Cloud communication client for manifest upload and Query API."""

apisec_code_bolt/cloud/apisec_client.py

@@ -0,0 +1,118 @@
+"""PAT-authenticated onboarding: register with applicationsservice, upload to reasoning engine."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from .client import CloudClient
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RegistrationResult:
+    """Result of POST /v1/applications/surface."""
+
+    app_id: str
+
+
+@dataclass
+class RepoInfo:
+    """Repository metadata for registration."""
+
+    repo_name: str
+    repo_url: str
+    branch: str
+    commit_sha: str
+    scm_provider: str
+    canonical_repo_id: str
+
+
+class ApisecClient:
+    """Registers the repo surface with applicationsservice (PAT), then talks to the reasoning engine with the same PAT."""
+
+    def __init__(
+        self,
+        api_url: str,
+        pat: str,
+        timeout_seconds: int = 60,
+        verify_ssl: bool = True,
+    ):
+        self._api_url = api_url.rstrip("/")
+        self._pat = pat
+        self._timeout = timeout_seconds
+        self._verify_ssl = verify_ssl
+
+    def register(
+        self,
+        repo_info: RepoInfo,
+        existing_app_id: str | None = None,
+        force_new_application: bool = False,
+    ) -> RegistrationResult:
+        """POST /v1/applications/surface with Bearer PAT; returns app id."""
+        body: dict[str, Any] = {
+            "repoName": repo_info.repo_name,
+            "repoUrl": repo_info.repo_url,
+            "branch": repo_info.branch,
+            "commitSha": repo_info.commit_sha,
+            "scmProvider": repo_info.scm_provider,
+            "canonicalRepoId": repo_info.canonical_repo_id,
+        }
+        if existing_app_id:
+            body["existingAppId"] = existing_app_id
+        if force_new_application:
+            body["forceNewApplication"] = True
+
+        with httpx.Client(
+            base_url=self._api_url,
+            timeout=httpx.Timeout(self._timeout),
+            verify=self._verify_ssl,
+        ) as client:
+            response = client.post(
+                "/v1/applications/surface",
+                json=body,
+                headers={"Authorization": f"Bearer {self._pat}"},
+            )
+            response.raise_for_status()
+            data = response.json()
+
+        app_id = data.get("appId") or data.get("app_id")
+        if not app_id:
+            raise ValueError("surface registration response missing appId")
+        result = RegistrationResult(app_id=str(app_id))
+        logger.info("Surface registration resolved app_id=%s", result.app_id)
+        return result
+
+    def upload_and_verify(
+        self,
+        registration: RegistrationResult,
+        manifest_data: dict[str, Any],
+        project_root: Path,
+        reasoning_engine_url: str | None = None,
+    ) -> dict[str, Any]:
+        """Upload manifest to reasoning engine with Bearer PAT and app_id; run verification."""
+        engine_url = reasoning_engine_url or self._api_url
+        with CloudClient(
+            api_url=engine_url,
+            api_key=self._pat,
+            app_id=registration.app_id,
+            verify_ssl=self._verify_ssl,
+        ) as client:
+            from ..query.executor import QueryExecutor
+
+            executor = QueryExecutor(project_root=project_root)
+            result = executor.run_connected(client, manifest_data)
+
+        return {
+            "analysis_id": result.analysis_id,
+            "status": result.final_status,
+            "rounds": result.stats.rounds_completed,
+            "questions_answered": result.stats.questions_answered,
+            "elapsed_seconds": result.stats.elapsed_seconds,
+            "error": result.error,
+        }

apisec_code_bolt/cloud/client.py

@@ -0,0 +1,255 @@
+"""
+HTTP client for communicating with the APIsec reasoning engine.
+
+Handles manifest upload, question polling, and answer submission.
+All communication is outbound-only (probe initiates).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class QuestionItem:
+    """A single verification question from the engine."""
+
+    id: str
+    type: str
+    gate_id: str
+    finding_id: str
+    round_number: int
+    target_file: str | None = None
+    target_function: str | None = None
+    target_line: int | None = None
+    params: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class QuestionBatchResult:
+    """Result of polling for questions."""
+
+    status: str
+    batch_id: str | None = None
+    round_number: int | None = None
+    questions: list[QuestionItem] = field(default_factory=list)
+    retry_after: int | None = None
+
+
+@dataclass
+class SubmitResult:
+    """Result of submitting answers."""
+
+    received: bool
+    answers_processed: int
+    more_questions: bool
+    status: str
+
+
+class CloudClient:
+    """HTTP client for the reasoning engine API."""
+
+    def __init__(
+        self,
+        api_url: str,
+        api_key: str | None = None,
+        *,
+        app_id: str | None = None,
+        timeout_seconds: int = 60,
+        retry_attempts: int = 3,
+        verify_ssl: bool = True,
+    ):
+        self._base_url = api_url.rstrip("/")
+        self._api_key = api_key
+        self._app_id = app_id
+        self._timeout = timeout_seconds
+        self._retries = retry_attempts
+
+        headers: dict[str, str] = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            headers=headers,
+            timeout=httpx.Timeout(timeout_seconds),
+            verify=verify_ssl,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> CloudClient:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Manifest upload
+    # ------------------------------------------------------------------
+
+    def upload_manifest(self, manifest_data: dict[str, Any]) -> tuple[str, str]:
+        """Upload a manifest and return (analysis_id, status)."""
+        if not self._app_id:
+            raise ValueError(
+                "app_id is required for manifest upload (register via POST /v1/applications/surface "
+                "or set application id in apisec-code-bolt/state.yaml / APISEC_APP_ID)",
+            )
+        path = f"/api/v1/manifests?app_id={quote(self._app_id, safe='')}"
+        response = self._post(path, json=manifest_data)
+        data = response.json()
+        analysis_id = data["analysis_id"]
+        status = data["status"]
+        logger.info(
+            "Manifest uploaded: analysis_id=%s status=%s message=%s",
+            analysis_id,
+            status,
+            data.get("message", ""),
+        )
+        return analysis_id, status
+
+    # ------------------------------------------------------------------
+    # Question polling
+    # ------------------------------------------------------------------
+
+    def poll_questions(
+        self,
+        analysis_id: str,
+        poll_timeout: int = 30,
+        max_wait: int = 300,
+    ) -> QuestionBatchResult:
+        """Poll for verification questions with retry and backoff.
+
+        Keeps polling until questions are ready, analysis is complete,
+        or max_wait is exceeded.
+        """
+        start = time.monotonic()
+        backoff = 1.0
+
+        while (time.monotonic() - start) < max_wait:
+            result = self._fetch_questions(analysis_id)
+
+            if result.status == "questions_ready":
+                return result
+            if result.status in ("complete", "failed"):
+                return result
+
+            wait = result.retry_after or backoff
+            logger.debug("No questions yet, retrying in %.1fs", wait)
+            time.sleep(wait)
+            backoff = min(backoff * 1.5, 10.0)
+
+        logger.warning("Question poll timed out after %ds", max_wait)
+        return QuestionBatchResult(status="timeout")
+
+    def _fetch_questions(self, analysis_id: str) -> QuestionBatchResult:
+        response = self._get(f"/api/v1/analyses/{analysis_id}/questions")
+        data = response.json()
+
+        questions = [
+            QuestionItem(
+                id=q["id"],
+                type=q["type"],
+                gate_id=q["gate_id"],
+                finding_id=q["finding_id"],
+                round_number=q.get("round_number", 1),
+                target_file=q.get("target_file"),
+                target_function=q.get("target_function"),
+                target_line=q.get("target_line"),
+                params=q.get("params", {}),
+            )
+            for q in data.get("questions", [])
+        ]
+
+        return QuestionBatchResult(
+            status=data["status"],
+            batch_id=data.get("batch_id"),
+            round_number=data.get("round_number"),
+            questions=questions,
+            retry_after=data.get("retry_after"),
+        )
+
+    # ------------------------------------------------------------------
+    # Answer submission
+    # ------------------------------------------------------------------
+
+    def submit_answers(
+        self,
+        analysis_id: str,
+        batch_id: str,
+        answers: list[dict[str, Any]],
+    ) -> SubmitResult:
+        """Submit answers for a batch of questions."""
+        payload = {"batch_id": batch_id, "answers": answers}
+        response = self._post(f"/api/v1/analyses/{analysis_id}/answers", json=payload)
+        data = response.json()
+
+        result = SubmitResult(
+            received=data["received"],
+            answers_processed=data["answers_processed"],
+            more_questions=data["more_questions"],
+            status=data["status"],
+        )
+        logger.info(
+            "Answers submitted: batch=%s processed=%d more_questions=%s",
+            batch_id,
+            result.answers_processed,
+            result.more_questions,
+        )
+        return result
+
+    # ------------------------------------------------------------------
+    # Analysis status
+    # ------------------------------------------------------------------
+
+    def get_analysis_status(self, analysis_id: str) -> dict[str, Any]:
+        response = self._get(f"/api/v1/analyses/{analysis_id}")
+        return response.json()
+
+    # ------------------------------------------------------------------
+    # HTTP helpers
+    # ------------------------------------------------------------------
+
+    def _get(self, path: str) -> httpx.Response:
+        return self._request("GET", path)
+
+    def _post(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self._request("POST", path, **kwargs)
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        last_exc: Exception | None = None
+
+        for attempt in range(self._retries + 1):
+            try:
+                response = self._client.request(method, path, **kwargs)
+                response.raise_for_status()
+                return response
+            except httpx.HTTPStatusError:
+                raise
+            except (httpx.TransportError, httpx.TimeoutException) as e:
+                last_exc = e
+                if attempt < self._retries:
+                    wait = 2**attempt
+                    logger.warning(
+                        "Request %s %s failed (attempt %d/%d): %s — retrying in %ds",
+                        method,
+                        path,
+                        attempt + 1,
+                        self._retries + 1,
+                        e,
+                        wait,
+                    )
+                    time.sleep(wait)
+
+        raise ConnectionError(
+            f"Failed after {self._retries + 1} attempts: {last_exc}"
+        ) from last_exc

apisec_code_bolt/core/__init__.py

@@ -0,0 +1,75 @@
+"""Core types, configuration, and manifest definitions."""
+
+from .config import (
+    AnalysisConfig,
+    CloudConfig,
+    CodeBoltConfig,
+    DataFlowConfig,
+    FileDiscoveryConfig,
+    JvmConfig,
+    OutputConfig,
+    QueryApiConfig,
+    get_default_config,
+    load_config,
+)
+from .manifest import MANIFEST_VERSION, Manifest
+from .types import (
+    AnalysisError,
+    AnalysisNote,
+    AuthDependencyType,
+    AuthSchemeType,
+    CallContext,
+    CloudCommunicationError,
+    CodeBoltError,
+    CodeLocation,
+    Confidence,
+    ConfigurationError,
+    FlowContext,
+    Framework,
+    HttpMethod,
+    Language,
+    OriginType,
+    ParameterLocation,
+    ParseError,
+    QualifiedName,
+    TransformationType,
+)
+
+__all__ = [
+    # Enums
+    "Language",
+    "Framework",
+    "OriginType",
+    "TransformationType",
+    "AuthSchemeType",
+    "AuthDependencyType",
+    "HttpMethod",
+    "ParameterLocation",
+    "Confidence",
+    # Data types
+    "CodeLocation",
+    "QualifiedName",
+    "CallContext",
+    "FlowContext",
+    "AnalysisNote",
+    # Config
+    "CodeBoltConfig",
+    "AnalysisConfig",
+    "FileDiscoveryConfig",
+    "DataFlowConfig",
+    "JvmConfig",
+    "CloudConfig",
+    "QueryApiConfig",
+    "OutputConfig",
+    "load_config",
+    "get_default_config",
+    # Manifest
+    "Manifest",
+    "MANIFEST_VERSION",
+    # Exceptions
+    "CodeBoltError",
+    "ParseError",
+    "ConfigurationError",
+    "AnalysisError",
+    "CloudCommunicationError",
+]