bevor-cli 0.1.0__py3-none-any.whl

bevor_cli/commands/codes/list.py

@@ -0,0 +1,90 @@
+"""``bevor code list`` — list code versions."""
+
+from typing import List, Optional
+
+import typer
+from bevor_sdk.types.literals import CodeVersionStatus, Network
+from bevor_sdk.types.requests.graph import CodeQueryParams
+from rich.table import Table
+from rich.text import Text
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.annotations.query import ORDER, ORDER_BY, PAGE, PAGE_SIZE
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.settings import Settings
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def list_code_versions(
+    page: PAGE = None,
+    page_size: PAGE_SIZE = None,
+    order: ORDER = None,
+    order_by: ORDER_BY = None,
+    project: Optional[str] = typer.Option(
+        None, "--project", help="Project to list for. Defaults to current configuration"
+    ),
+    network: Optional[Network] = typer.Option(
+        None,
+        "--network",
+        help="Network to filter by",
+    ),
+    identifier: Optional[str] = typer.Option(
+        None, "--identifier", help="Identifier (commit, hash, address) to filter by"
+    ),
+    status: Optional[CodeVersionStatus] = typer.Option(
+        None, "--status", help="Code status to filter by"
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """List code versions for the active project, or the passed --project."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    settings = Settings.load()
+
+    query_params = CodeQueryParams(
+        page=page,
+        page_size=page_size or settings.default_page_size,
+        order=order,
+        order_by=order_by,
+        network=network,
+        identifier=identifier,
+        status=status,
+    )
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project(priority=project)
+    )
+
+    codes = client.codes.list(query_params)
+
+    if json_out:
+        console.print_json(codes.model_dump_json(indent=2))
+        return
+
+    if not codes.results:
+        console.print("No code versions found.")
+        return
+
+    table = Table("ID", "STATUS", "CREATED", "METHOD")
+
+    for v in codes.results:
+        args: List[str | Text] = [
+            v.id,
+            v.status,
+            str(v.created_at.date()),
+            v.version_method,
+        ]
+        if state.code_id == v.id:
+            args.append(Text("●", style="bold green"))
+        table.add_row(*args)
+
+    console.print(table)
+
+    if codes.more:
+        output.info(f"\nShowing {codes.page} of {codes.total_pages}. Increase with --page-size/-n.")

bevor_cli/commands/codes/push.py

@@ -0,0 +1,76 @@
+"""``bevor code push`` — upload a directory as a code version."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from bevor_sdk.exceptions import NotFoundError
+from bevor_sdk.helpers.source_fingerprint import zip_source_tree
+from bevor_sdk.types import ID
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import NO_WAIT, YES
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def push_code(
+    path: Optional[Path] = typer.Option(None, "--path", help="Source tree root (default: cwd)."),
+    no_wait: NO_WAIT = False,
+    yes: YES = False,
+) -> None:
+    """Upload your current working directory to produce a new code version. Automatically updates your configured code version."""
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    project_id = state.validate_project()
+
+    client = BevorInternalClient(creds=creds, workspace_id=workspace_id, project_id=project_id)
+
+    if not yes:
+        project = client.projects.get()
+        if not typer.confirm(f"Create code within project '{project.name}'?"):
+            raise typer.Exit(0)
+
+    root = path or Path.cwd()
+    try:
+        with output.spinner("Packaging source tree..."):
+            zip_bytes, n_files, content_hash = zip_source_tree(root)
+    except ValueError as exc:
+        output.error(str(exc), hint="Make sure you're in the project root directory.")
+        raise typer.Exit(1)
+    size_kb = len(zip_bytes) // 1024
+    output.info(f"Compressed {n_files} files → {size_kb} KB")
+
+    if state.code_id and state.code_fingerprint == content_hash:
+        # requests are project-scoped, so a code that still resolves belongs to the linked project.
+        try:
+            client.codes.get(ID(state.code_id))
+            output.info("No changes detected from the current code version")
+            return
+        except NotFoundError:
+            pass
+
+    with output.spinner("Uploading..."):
+        # no harm in this being called regardless.
+        signing_key = client.codes.generate_signing_key()
+        result = client.codes.upload_folder_zip(
+            signing_key=signing_key, zip_bytes=zip_bytes, with_streaming=True
+        )
+
+    if result.data.status == "failed":
+        output.error("Code processing failed on the server.")
+        raise typer.Exit(1)
+
+    state.set_code(result.data)
+    state.save()
+
+    if result.data.status in ("processing", "queued") and not no_wait:
+        with output.spinner("Processing code..."):
+            result.stream_completion()
+
+    output.success(f"Code version: {result.data.id}")

bevor_cli/commands/codes/select.py

@@ -0,0 +1,93 @@
+"""``bevor codes select`` — set the selected code version."""
+
+from typing import Optional
+
+import questionary
+import typer
+from bevor_sdk.exceptions import NotFoundError
+from bevor_sdk.types import ID
+from bevor_sdk.types.literals import CodeVersionStatus
+from bevor_sdk.types.requests.graph import CodeQueryParams
+from bevor_sdk.types.responses.graph import CodeMappingSchema
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.settings import Settings
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+from bevor_cli.select import _CANCEL, _select
+
+
+def select_code(
+    code_id: Optional[str] = typer.Argument(
+        None, help="Code version id to select. Prompts with a list when omitted."
+    ),
+) -> None:
+    """Select a code version in the selected project by id, or pick one from a list."""
+    if code_id is None:
+        pick_code()
+        return
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    try:
+        code = client.codes.get(ID(code_id))
+    except NotFoundError:
+        output.error("code not found in the configured project")
+        raise typer.Exit(1)
+
+    state.set_code(code)
+    state.save()
+    output.info("Updated code configuration")
+
+
+def pick_code(
+    *,
+    page: Optional[int] = None,
+    status: Optional[CodeVersionStatus] = None,
+    page_size: Optional[int] = None,
+) -> None:
+    """Interactive picker for code versions in the configured project."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    settings = Settings.load()
+
+    codes = client.codes.list(
+        CodeQueryParams(page=page, status=status, page_size=page_size or settings.default_page_size)
+    )
+
+    if not codes.results:
+        console.print("No code versions found.")
+        return
+
+    choices = [
+        questionary.Choice(
+            title=f"{c.status} · {c.id} {c.created_at.date()}",
+            value=c,
+        )
+        for c in codes.results
+    ] + [questionary.Choice(title="↵ Cancel", value=_CANCEL)]
+
+    code: CodeMappingSchema | None = _select("Select a code version:", choices)
+    if code is None:
+        raise typer.Exit(0)
+
+    state.set_code(code)
+    state.save()
+    output.info("Updated code configuration")

bevor_cli/commands/codes/view.py

@@ -0,0 +1,80 @@
+"""``bevor codes view`` — show a code version (the selected one by default)."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from bevor_sdk.helpers.source_fingerprint import zip_source_tree
+from bevor_sdk.types import ID
+from rich.table import Table
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def view_code(
+    code_id: Optional[str] = typer.Argument(
+        None, help="Code version id. Defaults to the selected code version."
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """Print details for a code version, or the selected one."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    code_id = code_id or state.code_id
+    if not code_id:
+        output.error(
+            "No code version is configured.",
+            hint="Run `bevor codes push` or `bevor codes select`.",
+        )
+        raise typer.Exit(1)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+    code = client.codes.get(ID(code_id))
+
+    if json_out:
+        console.print_json(code.model_dump_json(indent=2))
+        return
+
+    root = Path.cwd()
+    _, _, content_hash = zip_source_tree(root)
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+
+    table.add_row("ID", code.id)
+    table.add_row("Status", code.status)
+    table.add_row("Version method", code.version_method)
+    table.add_row("Fingerprint", code.version_fingerprint)
+    table.add_row("In sync (cwd)", str(content_hash == code.version_fingerprint))
+    table.add_row("Created", str(code.created_at.date()))
+
+    if code.network:
+        table.add_row("Network", code.network)
+
+    if code.branch:
+        table.add_row("Branch", code.branch)
+
+    if code.commit:
+        c = code.commit
+        sha_short = c.sha[:7] if len(c.sha) >= 7 else c.sha
+        msg = c.message.split("\n", 1)[0][:80]
+        table.add_row("Commit", f"{sha_short}  {msg}")
+
+    if code.repository:
+        r = code.repository
+        table.add_row("GitHub", r.full_name)
+        table.add_row("Repo URL", r.url)
+
+    console.print(table)

bevor_cli/commands/context/__init__.py

@@ -0,0 +1,92 @@
+"""bevor context — show `.bevor` context for this directory."""
+
+import json
+from typing import Any, Dict
+
+import typer
+from bevor_sdk.types import ID
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.client import BevorInternalBusinessClient, BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def run_context(
+    json_out: JSON_OUT = False,
+) -> None:
+    """Show workspace, project, code, and analysis from `.bevor` (and live labels where available)."""
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    payload: Dict[str, Any] = {}
+
+    try:
+        workspace = BevorInternalBusinessClient(
+            creds=creds, workspace_id=workspace_id
+        ).get_workspace()
+    except Exception:
+        output.error(
+            f"Workspace {state.workspace_id} no longer exists (deleted on dashboard?).",
+            hint="Run `bevor link` to reconfigure.",
+        )
+        raise typer.Exit(1)
+
+    lines = [f"Workspace : {workspace.name}  [{workspace.id}]"]
+    payload["workspace"] = workspace.model_dump(mode="json")
+    payload["project"] = None
+    payload["code"] = None
+    payload["analysis"] = None
+
+    if not state.project_id:
+        lines += ["Project : (not set)", "Code : (not set)", "Analysis : (not set)"]
+    else:
+        client = BevorInternalClient(
+            creds=creds, workspace_id=workspace_id, project_id=state.project_id
+        )
+
+        try:
+            project = client.projects.get()
+            lines.append(f"Project : {project.name}  [{project.id}]")
+            payload["project"] = project.model_dump(mode="json")
+        except Exception:
+            lines.append(f"Project : (stale — {state.project_id} not found)")
+
+        if state.code_id:
+            try:
+                code = client.codes.get(ID(state.code_id))
+                lines.append(f"Code : {code.id}")
+                payload["code"] = code.model_dump(mode="json")
+            except Exception:
+                lines.append(f"Code : (stale — {state.code_id} not found)")
+        else:
+            lines.append("Code : (not set)")
+
+        if state.analysis_id:
+            try:
+                analysis = client.analyses.get(ID(state.analysis_id))
+                lines.append(
+                    f"Analysis : {analysis.name} {analysis.version.code_version.id} [{analysis.id}]"
+                )
+                payload["analysis"] = analysis.model_dump(mode="json")
+            except Exception:
+                lines.append(f"Analysis : (stale — {state.analysis_id} not found)")
+        else:
+            lines.append("Analysis : (not set)")
+
+    payload["config"] = state.model_dump(mode="json")
+
+    if json_out:
+        console.print_json(json.dumps(payload, indent=2, default=str))
+        return
+
+    for line in lines:
+        print(line)
+
+    output.info("\nChange any of these with `bevor \\[resource] select [id]`")

bevor_cli/commands/findings/acknowledge.py

@@ -0,0 +1,28 @@
+"""``bevor findings validate``."""
+
+import typer
+from bevor_sdk.types import ID
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def acknowledge_finding(
+    finding_id: str = typer.Argument(..., help="Finding id to toggle validation for."),
+) -> None:
+    """Toggle acknowledgement status for a finding."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    client.findings.toggle_acknowledgement(ID(finding_id))
+
+    output.success("Finding validation toggled.")

bevor_cli/commands/findings/add.py

@@ -0,0 +1,236 @@
+from pathlib import Path
+from typing import Optional, cast, get_args
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.literals import FindingLevel, FindingType
+from bevor_sdk.types.requests.security import (
+    FindingBodyDict,
+    FindingLocationLogicalDict,
+    FindingLocationNodeIdDict,
+    FindingLocationPhysicalDict,
+    FindingMetadataDict,
+)
+from bevor_sdk.types.requests.security.findings import AddFindingBodyDict
+from rich.prompt import Confirm, Prompt
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.findings_yaml import (
+    FindingFormatError,
+    FindingYamlParser,
+)
+
+
+def _pick_from_list(options: list[str], title: str) -> str:
+    typer.echo(title)
+    for i, x in enumerate(options, 1):
+        typer.echo(f"  [{i}] {x}")
+    raw = typer.prompt(f"Number 1–{len(options)}, or type the value", default="1").strip()
+    try:
+        idx = int(raw)
+        if 1 <= idx <= len(options):
+            return options[idx - 1]
+    except ValueError:
+        pass
+    if raw in options:
+        return raw
+    output.error(f"Unknown choice: {raw!r}")
+    raise typer.Exit(1)
+
+
+def _interactive_parsed_doc(
+    tool: str | None = None, node_id: Optional[str] = None
+) -> FindingBodyDict:
+    if node_id:
+        scope_raw = node_id
+        typer.echo(f"Entry point node id: {scope_raw}")
+    else:
+        scope_raw = ""
+        while not scope_raw:
+            scope_raw = Prompt.ask("Entry point node id", show_default=False).strip()
+            if not scope_raw:
+                output.info("Scope is required.")
+
+    location = FindingLocationNodeIdDict(strategy="node_id", node_id=scope_raw)
+
+    finding_body = FindingBodyDict(tool=tool, location=location)
+
+    has_finding = Confirm.ask(
+        "Is there a finding associated with this node? ('n' if you just want to mark the node as analyzed)"
+    )
+
+    if has_finding:
+        ftype = Prompt.ask("Finding type:")
+        lvl = _pick_from_list(list(get_args(FindingLevel)), "Severity level:")
+        name = ""
+        while not name:
+            name = Prompt.ask("Finding title / name")
+            if not name:
+                output.info("Name is required.")
+
+        explanation = ""
+        while not explanation:
+            explanation = Prompt.ask("Explanation").strip()
+            if not explanation:
+                output.info("Explanation is required.")
+
+        rec = Prompt.ask("Recommendation (optional)", default="", show_default=False).strip()
+        poc = Prompt.ask("POC (optional)", default="", show_default=False).strip()
+
+        finding_body["metadata"] = FindingMetadataDict(
+            type=cast(FindingType, ftype),
+            level=cast(FindingLevel, lvl),
+            name=name.strip(),
+            explanation=explanation,
+            recommendation=rec,
+            poc=poc,
+        )
+
+    return finding_body
+
+
+def add_finding(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id to stage against (default: configured analysis head).",
+    ),
+    file: Path | None = typer.Option(
+        None, "--file", help="YAML file containing exactly one finding mapping."
+    ),
+    interactive: bool = typer.Option(False, "--interactive", help="Force interactive prompts."),
+    # finding fields
+    type_: Optional[str] = typer.Option(None, "--type"),
+    level: Optional[FindingLevel] = typer.Option(None, "--level"),
+    name: Optional[str] = typer.Option(None, "--name"),
+    explanation: Optional[str] = typer.Option(None, "--explanation"),
+    recommendation: Optional[str] = typer.Option(None, "--recommendation"),
+    poc: Optional[str] = typer.Option(None, "--poc"),
+    tool: Optional[str] = typer.Option(None, "--tool"),
+    # node_id
+    node_id: Optional[str] = typer.Option(None, "--node"),
+    location_id: Optional[str] = typer.Option(None, "--location"),
+    # physical
+    uri: Optional[str] = typer.Option(None, "--uri"),
+    start_line: Optional[int] = typer.Option(None, "--start-line"),
+    start_column: Optional[int] = typer.Option(None, "--start-column"),
+    end_line: Optional[int] = typer.Option(None, "--end-line"),
+    end_column: Optional[int] = typer.Option(None, "--end-column"),
+    char_offset: Optional[int] = typer.Option(None, "--char-offset"),
+    char_length: Optional[int] = typer.Option(None, "--char-length"),
+    byte_offset: Optional[int] = typer.Option(None, "--byte-offset"),
+    byte_length: Optional[int] = typer.Option(None, "--byte-length"),
+    # logical
+    fully_qualified_name: Optional[str] = typer.Option(None, "--fqn"),
+) -> None:
+    """Stage a new finding to your currently configured analysis, or to the --version.
+
+    Provide input one of three ways:
+
+    - ``--file``: a YAML file with exactly one finding mapping.
+    - ``--interactive``: prompts for each field.
+    - Flags directly, as described below.
+
+    When passing flags, specify a location, which specifies the code node that the finding is associated with, using exactly one of:
+
+    - ``--node`` and/or ``--location`` (a Bevor node id; ``--location`` alone
+      fans the finding out to every entrypoint that reaches it)
+    - ``--uri`` plus one full pair of ``--start-line``/``--end-line``,
+      ``--char-offset``/``--char-length``, or ``--byte-offset``/``--byte-length``
+    - ``--fqn``
+
+    Metadata (``--type``, ``--level``, ``--name``, ``--explanation``) is all or
+    nothing: provide all four to record a finding, or omit all four to mark the
+    location as analyzed with no finding. ``--recommendation``, ``--reference``,
+    and ``--tool`` are always optional.
+    """
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    body = AddFindingBodyDict(findings=[])
+    if version is None:
+        analysis_id = state.validate_analysis()
+    else:
+        version_id = ID(version)
+        v_ = client.analysis_versions.get(version_id)
+        analysis_id = v_.analysis_meta.id
+        body["version_id"] = version_id
+
+    finding_body = None
+    location = None
+    if interactive:
+        finding_body = _interactive_parsed_doc(node_id=node_id, tool=tool)
+    elif file is not None:
+        try:
+            finding_yaml = FindingYamlParser.from_file(path=file)
+            finding_body = finding_yaml.parse()
+        except OSError as exc:
+            output.error(f"Cannot read file: {exc}")
+            raise typer.Exit(1) from exc
+        except FindingFormatError as exc:
+            output.error(
+                str(exc),
+                hint=(
+                    "One YAML mapping per file. For many findings use "
+                    "``bevor agent submit`` "
+                    "(one ``.yaml`` per finding under ``--dir``)."
+                ),
+            )
+            raise typer.Exit(1) from exc
+    elif node_id:
+        location = FindingLocationNodeIdDict(
+            strategy="node_id", node_id=node_id, location_id=location_id
+        )
+    elif uri:
+        location = FindingLocationPhysicalDict(
+            strategy="physical",
+            uri=uri,
+            startLine=start_line,
+            startColumn=start_column,
+            endLine=end_line,
+            endColumn=end_column,
+            charOffset=char_offset,
+            charLength=char_length,
+            byteOffset=byte_offset,
+            byteLength=byte_length,
+        )
+    elif fully_qualified_name:
+        location = FindingLocationLogicalDict(
+            strategy="logical", fully_qualified_name=fully_qualified_name
+        )
+    else:
+        output.error(
+            "--interactive mode, a file path, or location by node, physical, or logical is required"
+        )
+        raise typer.Exit(1)
+
+    if not finding_body:
+        assert location is not None
+
+        finding_body = FindingBodyDict(tool=tool, location=location)
+
+        if type_ and level and name and explanation:
+            finding_body["metadata"] = FindingMetadataDict(
+                type=type_,
+                level=level,
+                name=name,
+                explanation=explanation,
+                recommendation=recommendation,
+                poc=poc,
+            )
+
+    body["findings"] = [finding_body]
+
+    findings_added = client.analyses.add_findings(analysis_id=analysis_id, body=body)
+
+    output.success(f"{len(findings_added.results)} Finding staged.")