prismor-cli 1.3.0__py3-none-any.whl

prismor/cli_config.py

@@ -0,0 +1,55 @@
+"""Local CLI config (~/.prismor/cli-config.json).
+
+Today this stores the active organization for users who belong to more than one
+org — the `prismor org switch` target. The CLI sends it as org_id on scan/fix;
+the control plane only honors it if the user is a member (else it falls back to
+the key's default org), so this is a convenience, not an auth boundary.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def _config_dir() -> Path:
+    return Path(os.environ.get("PRISMOR_HOME", str(Path.home() / ".prismor")))
+
+
+def _config_path() -> Path:
+    return _config_dir() / "cli-config.json"
+
+
+def load() -> Dict[str, Any]:
+    try:
+        data = json.loads(_config_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def save(cfg: Dict[str, Any]) -> None:
+    d = _config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    _config_path().write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+
+
+def active_org() -> Optional[Dict[str, Any]]:
+    """The active org dict ({id, slug, name}) or None."""
+    org = load().get("active_org")
+    return org if isinstance(org, dict) and org.get("id") else None
+
+
+def active_org_id() -> Optional[str]:
+    org = active_org()
+    return org.get("id") if org else None
+
+
+def set_active_org(org: Optional[Dict[str, Any]]) -> None:
+    cfg = load()
+    if org:
+        cfg["active_org"] = {"id": org.get("id"), "slug": org.get("slug"), "name": org.get("name")}
+    else:
+        cfg.pop("active_org", None)
+    save(cfg)

prismor/local_fix.py

@@ -0,0 +1,338 @@
+"""Local AI auto-fix: apply security fixes on the user's own machine.
+
+Scanning stays in the Prismor cloud; this path takes the resulting findings and
+hands them to a coding agent the user already has installed (Claude Code, Codex,
+...). The agent edits the user's local checkout using the user's own LLM
+credentials. Nothing sensitive — source code, GitHub token — leaves the machine,
+and Prismor's hosted fix agent is never invoked.
+"""
+
+import os
+import sys
+import json
+import shlex
+import shutil
+import subprocess
+from typing import List, Optional, Tuple
+
+import click
+
+from .sanitize import build_fix_prompt, count_findings
+from .api import PrismorClient, PrismorAPIError
+
+
+class AgentNotFound(Exception):
+    """Raised when no usable local coding agent can be resolved."""
+
+
+def _claude_argv(prompt: str) -> List[str]:
+    # Headless print mode; auto-accept file edits but still gate shell commands.
+    return ["claude", "-p", prompt, "--permission-mode", "acceptEdits"]
+
+
+def _codex_argv(prompt: str) -> List[str]:
+    return ["codex", "exec", prompt]
+
+
+# Coding agents we know how to invoke headlessly. Order = auto-detect priority.
+AGENT_SPECS = {
+    "claude": {"label": "Claude Code", "bin": "claude", "argv": _claude_argv},
+    "codex": {"label": "OpenAI Codex CLI", "bin": "codex", "argv": _codex_argv},
+}
+AGENT_PRIORITY = ["claude", "codex"]
+
+# Env var to point Prismor at any other agent. Must contain a {prompt}
+# placeholder; the substituted command is run through the shell, e.g.:
+#   export PRISMOR_LOCAL_AGENT_CMD='aider --yes --message {prompt}'
+CUSTOM_AGENT_ENV = "PRISMOR_LOCAL_AGENT_CMD"
+
+
+def build_agent_command(prompt: str, preferred: str = "auto") -> Tuple[str, object, bool]:
+    """Resolve which agent to run and build its invocation.
+
+    Args:
+        prompt: The fix prompt to hand to the agent.
+        preferred: ``"auto"`` to detect from PATH, or a specific agent key.
+
+    Returns:
+        ``(label, command, use_shell)`` where ``command`` is an argv list when
+        ``use_shell`` is False, or a shell string when True.
+
+    Raises:
+        AgentNotFound: with message ``"no-agent"`` when nothing is installed,
+            or a descriptive message for other resolution failures.
+    """
+    custom = os.environ.get(CUSTOM_AGENT_ENV)
+    if custom:
+        if "{prompt}" not in custom:
+            raise AgentNotFound(
+                f"{CUSTOM_AGENT_ENV} must contain a {{prompt}} placeholder."
+            )
+        return ("custom agent", custom.replace("{prompt}", shlex.quote(prompt)), True)
+
+    if preferred and preferred != "auto":
+        spec = AGENT_SPECS.get(preferred)
+        if spec and shutil.which(spec["bin"]):
+            return (spec["label"], spec["argv"](prompt), False)
+        binary = spec["bin"] if spec else preferred
+        raise AgentNotFound(
+            f"Requested agent '{preferred}' is not installed "
+            f"(couldn't find '{binary}' on your PATH)."
+        )
+
+    for kind in AGENT_PRIORITY:
+        spec = AGENT_SPECS[kind]
+        if shutil.which(spec["bin"]):
+            return (spec["label"], spec["argv"](prompt), False)
+    raise AgentNotFound("no-agent")
+
+
+def run_agent_command(command, use_shell: bool, cwd: str) -> int:
+    """Run the agent in ``cwd`` streaming its output live. Returns the exit code.
+
+    The whole fix prompt is passed as an argument, so the agent never needs to
+    read stdin. We redirect stdin from /dev/null so headless agents (e.g.
+    ``claude -p``) don't stall waiting for piped input when launched
+    non-interactively.
+    """
+    try:
+        proc = subprocess.run(command, cwd=cwd, shell=use_shell, stdin=subprocess.DEVNULL)
+        return proc.returncode
+    except FileNotFoundError:
+        return 127
+    except KeyboardInterrupt:
+        return 130
+
+
+def load_findings(results_file: Optional[str], from_scan: Optional[str]) -> dict:
+    """Load scan findings from a results file/stdin or a completed cloud scan job.
+
+    Raises PrismorAPIError("__no_source__") when neither source is provided so the
+    caller can print tailored guidance.
+    """
+    if results_file:
+        if results_file == "-":
+            raw = sys.stdin.read()
+        else:
+            with open(results_file, "r", encoding="utf-8") as f:
+                raw = f.read()
+        data = json.loads(raw)
+        # Accept either the bare results dict or a status payload wrapping it.
+        if isinstance(data, dict) and isinstance(data.get("results"), dict):
+            return data["results"]
+        return data
+
+    if from_scan:
+        client = PrismorClient()
+        status = client.check_scan_status(from_scan)
+        state = status.get("status")
+        if state not in {"completed", "success"}:
+            raise PrismorAPIError(
+                f"Scan job '{from_scan}' is not finished (status: {state}). "
+                f"Wait for it with: prismor scan-status {from_scan} --watch"
+            )
+        return status.get("results", status)
+
+    raise PrismorAPIError("__no_source__")
+
+
+def _is_git_repo(path: str) -> bool:
+    try:
+        r = subprocess.run(
+            ["git", "-C", path, "rev-parse", "--is-inside-work-tree"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return r.returncode == 0 and r.stdout.strip() == "true"
+    except Exception:
+        return False
+
+
+def _create_branch(path: str, name: str) -> Tuple[bool, str]:
+    try:
+        r = subprocess.run(
+            ["git", "-C", path, "checkout", "-b", name],
+            capture_output=True, text=True, timeout=15,
+        )
+        if r.returncode == 0:
+            return True, ""
+        return False, (r.stderr or r.stdout).strip()
+    except Exception as e:
+        return False, str(e)
+
+
+def _print_diff_stat(path: str) -> None:
+    try:
+        r = subprocess.run(
+            ["git", "-C", path, "--no-pager", "diff", "--stat"],
+            capture_output=True, text=True, timeout=15,
+        )
+        out = (r.stdout or "").strip()
+        if out:
+            click.secho("\nLocal changes:", fg="yellow", bold=True)
+            click.echo(out)
+        else:
+            click.secho("\nNo file changes detected in the working tree.", fg="yellow")
+    except Exception:
+        pass
+
+
+@click.command("fix-local")
+@click.argument("path", type=click.Path(exists=True, file_okay=False), default=".")
+@click.option("--results", "results_file", type=str, metavar="FILE",
+              help="Scan results JSON from `prismor --scan -o FILE`. Use '-' for stdin.")
+@click.option("--from-scan", "from_scan", type=str, metavar="JOB_ID",
+              help="Pull findings from a completed cloud scan job (needs PRISMOR_API_KEY).")
+@click.option("--agent", type=click.Choice(["auto", "claude", "codex"]), default="auto",
+              help="Coding agent to drive (default: auto-detect). Override fully with PRISMOR_LOCAL_AGENT_CMD.")
+@click.option("--instruction", type=str, help="Extra instruction appended to the fix prompt.")
+@click.option("--branch", "new_branch", type=str, metavar="NAME",
+              help="Create & switch to this local git branch before fixing.")
+@click.option("--dry-run", is_flag=True,
+              help="Print the resolved agent and prompt, then exit without editing.")
+@click.option("--yes", "-y", "assume_yes", is_flag=True, help="Skip the confirmation prompt.")
+def fix_local(path: str, results_file: Optional[str], from_scan: Optional[str], agent: str,
+              instruction: Optional[str], new_branch: Optional[str], dry_run: bool,
+              assume_yes: bool):
+    """Apply AI security fixes locally using your own coding agent.
+
+    Scanning still runs in the Prismor cloud; this command takes those findings
+    and fixes them on YOUR machine with YOUR installed coding agent (Claude Code,
+    Codex, ...) and YOUR own LLM credits. Your source code and GitHub token never
+    leave your machine, and Prismor's hosted fix agent is not used.
+
+    PATH is the local checkout to fix (default: current directory).
+
+    Examples:
+        prismor --repo me/app --scan -o findings.json   # 1. scan in cloud
+        prismor fix-local --results findings.json        # 2. fix locally
+
+        prismor fix-local . --from-scan <job_id>
+        prismor fix-local ~/code/app --agent claude --branch security-fixes
+        prismor fix-local --results findings.json --dry-run
+    """
+    # Deferred import: cli.py imports this module at load time, so importing its
+    # console helpers here (rather than at module top) avoids a circular import.
+    from .cli import print_info, print_success, print_error, print_warning, should_show_spinner
+
+    target = os.path.abspath(path)
+
+    # 1. Load findings (scan stays in the cloud; we only consume its output).
+    try:
+        results = load_findings(results_file, from_scan)
+    except PrismorAPIError as e:
+        if str(e) == "__no_source__":
+            print_error("No findings source given.")
+            click.echo("Provide one of:")
+            click.echo("  --results FILE      output of: prismor --repo <repo> --scan -o FILE")
+            click.echo("  --from-scan JOB_ID  a completed cloud scan job")
+            sys.exit(1)
+        print_error(str(e))
+        sys.exit(1)
+    except FileNotFoundError:
+        print_error(f"Results file not found: {results_file}")
+        sys.exit(1)
+    except (OSError, json.JSONDecodeError) as e:
+        print_error(f"Could not read findings JSON: {e}")
+        sys.exit(1)
+
+    if not isinstance(results, dict):
+        print_error("Findings JSON is not in the expected object format.")
+        sys.exit(1)
+
+    counts = count_findings(results)
+    total = counts["vulnerabilities"] + counts["secrets"]
+    if total == 0:
+        print_success("No findings to fix — nothing to do.")
+        return
+
+    # 2. Build the apply-mode prompt for a local agent.
+    prompt = build_fix_prompt(results, label=target, mode="apply", extra_instruction=instruction)
+
+    # 3. Resolve the agent.
+    try:
+        label, command, use_shell = build_agent_command(prompt, agent)
+    except AgentNotFound as e:
+        if str(e) == "no-agent":
+            print_error("No supported coding agent found on your PATH.")
+            click.echo("Install one of:")
+            click.echo("  • Claude Code:  https://docs.claude.com/claude-code")
+            click.echo("  • Codex CLI:    https://github.com/openai/codex")
+            click.echo("\nOr point Prismor at any agent via PRISMOR_LOCAL_AGENT_CMD, e.g.:")
+            click.secho("  export PRISMOR_LOCAL_AGENT_CMD='aider --yes --message {prompt}'", fg="cyan")
+        else:
+            print_error(str(e))
+        sys.exit(1)
+
+    # 4. Dry run: show the plan and prompt, change nothing.
+    if dry_run:
+        click.echo("\n" + "=" * 60)
+        click.secho("  fix-local (dry run)", fg="cyan", bold=True)
+        click.echo("=" * 60 + "\n")
+        click.secho("Agent:", fg="yellow", bold=True)
+        click.echo(f"  {label}")
+        click.secho("Target directory:", fg="yellow", bold=True)
+        click.echo(f"  {target}")
+        click.secho("Findings:", fg="yellow", bold=True)
+        click.echo(f"  {counts['vulnerabilities']} vulnerabilities, {counts['secrets']} secrets")
+        click.echo("\n" + "-" * 60)
+        click.secho("Prompt that would be sent to the agent:\n", fg="yellow", bold=True)
+        click.echo(prompt)
+        return
+
+    # 5. Confirm before editing the working tree.
+    click.echo("\n" + "=" * 60)
+    click.secho("  Local AI Auto-Fix", fg="cyan", bold=True)
+    click.echo("=" * 60 + "\n")
+    print_info(f"Agent:  {label}")
+    print_info(f"Target: {target}")
+    print_info(f"Findings: {counts['vulnerabilities']} vulnerabilities, {counts['secrets']} secrets")
+    print_warning("The agent will edit files in the target directory using your own LLM credits.")
+
+    if not assume_yes:
+        if not should_show_spinner():
+            print_error("Refusing to edit files non-interactively. Re-run with --yes to proceed.")
+            sys.exit(1)
+        if not click.confirm("Proceed?", default=False):
+            print_warning("Aborted. No files were changed.")
+            return
+
+    # 6. Optional local branch.
+    if new_branch:
+        if not _is_git_repo(target):
+            print_error(f"--branch requires a git repository; {target} is not one.")
+            sys.exit(1)
+        ok, err = _create_branch(target, new_branch)
+        if ok:
+            print_success(f"Created and switched to branch '{new_branch}'.")
+        else:
+            print_error(f"Could not create branch '{new_branch}': {err}")
+            sys.exit(1)
+
+    # 7. Hand off to the agent (output streams live).
+    click.echo()
+    print_info(f"Handing off to {label}…")
+    click.echo("-" * 60)
+    rc = run_agent_command(command, use_shell, target)
+    click.echo("-" * 60)
+
+    # 8. Report outcome.
+    if rc == 130:
+        print_warning("Interrupted. The working tree may contain partial changes.")
+        sys.exit(130)
+    if rc == 127:
+        print_error(f"{label} could not be launched (command not found).")
+        sys.exit(1)
+    if rc != 0:
+        print_error(f"{label} exited with code {rc}. Review any partial changes before committing.")
+        if _is_git_repo(target):
+            _print_diff_stat(target)
+        sys.exit(rc)
+
+    print_success("Local auto-fix finished.")
+    if _is_git_repo(target):
+        _print_diff_stat(target)
+        click.secho("\nNext steps:", fg="cyan", bold=True)
+        click.echo("  1. Review the changes:        git diff")
+        click.echo("  2. Run your tests.")
+        click.echo("  3. Commit & push with your own credentials, then open a PR.")
+    click.echo()

prismor/sanitize.py

@@ -0,0 +1,179 @@
+"""Shared helpers for sanitizing scan results and building fix prompts.
+
+These live in their own module so both the CLI output path (`prismor/cli.py`)
+and the local-fix path (`prismor/local_fix.py`) use one source of truth and
+avoid a circular import.
+"""
+
+import json
+import re
+from typing import Optional
+
+# Keys whose values are short-lived credentials / signed URLs that must never
+# be written to a file, printed, or handed to a local coding agent.
+_SENSITIVE_KEYS = {"presigned_url", "AWSAccessKeyId", "Signature", "x-amz-security-token"}
+
+# Server-side scratch paths (the backend clones into /tmp). Replace with a
+# placeholder so output doesn't leak Prismor's internal filesystem layout.
+_INTERNAL_PATH_RE = re.compile(r"^/(?:tmp|var/folders|private/tmp)/[^/\s]+")
+
+
+def _redact_ai_insight(insight: dict) -> dict:
+    """Replace raw upstream LLM errors in ai_insights with a generic notice.
+
+    The server leaves OpenAI 429s / billing URLs in the response; don't surface those.
+    """
+    if not isinstance(insight, dict):
+        return insight
+    err = insight.get("error")
+    if isinstance(err, str) and err.strip():
+        cleaned = dict(insight)
+        cleaned["error"] = "AI insight unavailable (upstream model error)"
+        if isinstance(cleaned.get("summary"), str) and "Error generating" in cleaned["summary"]:
+            cleaned["summary"] = "AI insight unavailable for this CVE."
+        return cleaned
+    return insight
+
+
+def strip_sensitive(obj):
+    """Recursively drop presigned URLs, redact internal temp paths, and sanitize
+    raw upstream-LLM error blobs from output."""
+    if isinstance(obj, dict):
+        cleaned = {}
+        for k, v in obj.items():
+            if k in _SENSITIVE_KEYS:
+                continue
+            if k == "ArtifactName" and isinstance(v, str) and _INTERNAL_PATH_RE.match(v):
+                cleaned[k] = "<repository>"
+                continue
+            if k == "insight":
+                cleaned[k] = _redact_ai_insight(v) if isinstance(v, dict) else v
+                continue
+            cleaned[k] = strip_sensitive(v)
+        return cleaned
+    if isinstance(obj, list):
+        return [strip_sensitive(v) for v in obj]
+    return obj
+
+
+def extract_vulnerabilities(results: dict) -> list:
+    """Pull a flat list of vulnerability dicts out of a scan-results payload.
+
+    Handles both the legacy flat ``vulnerabilities`` list and the Trivy
+    ``Results[].Vulnerabilities[]`` shape.
+    """
+    scans = (results or {}).get("scans") or {}
+    vuln_scan = scans.get("vulnerability") or {}
+    scan_data = vuln_scan.get("scan_results") or {}
+    if not isinstance(scan_data, dict):
+        return []
+
+    flat = scan_data.get("vulnerabilities")
+    if isinstance(flat, list) and flat and isinstance(flat[0], dict) and "Severity" in flat[0]:
+        return flat
+
+    vulns = []
+    for target in scan_data.get("Results", []) or []:
+        if isinstance(target, dict):
+            vulns.extend(target.get("Vulnerabilities") or [])
+    if not vulns:
+        top = scan_data.get("Results", [])
+        if isinstance(top, list) and top and isinstance(top[0], dict) and "Severity" in top[0]:
+            vulns = top
+    return vulns
+
+
+def count_findings(results: dict) -> dict:
+    """Return {'vulnerabilities': int, 'secrets': int} for a scan-results payload."""
+    vulns = len(extract_vulnerabilities(results))
+
+    secrets = 0
+    secret_scan = ((results or {}).get("scans") or {}).get("secret") or {}
+    summary = secret_scan.get("summary")
+    if isinstance(summary, dict):
+        ai_triage = summary.get("ai_triage")
+        if isinstance(ai_triage, dict) and isinstance(ai_triage.get("real_secrets"), int):
+            secrets = ai_triage["real_secrets"]
+        elif isinstance(summary.get("total"), int):
+            secrets = summary["total"]
+
+    return {"vulnerabilities": vulns, "secrets": secrets}
+
+
+def _prompt_scan_data(results: dict) -> dict:
+    """Build the sanitized, brevity-trimmed scan-data block embedded in a prompt."""
+    prompt_data = {k: v for k, v in results.items() if k != "scans"}
+    if "scans" in results:
+        prompt_data["scans"] = {}
+        for s_type, s_data in results["scans"].items():
+            if s_type == "sbom":
+                prompt_data["scans"][s_type] = {
+                    "status": (s_data or {}).get("status"),
+                    "message": "SBOM data omitted for brevity",
+                }
+            else:
+                prompt_data["scans"][s_type] = s_data
+    return strip_sensitive(prompt_data)
+
+
+_ADVISE_INSTRUCTIONS = """## Instructions for AI Agent:
+1. Review the vulnerabilities and secrets detected above.
+2. For each finding, locate the vulnerable code in the repository.
+3. Provide the necessary code changes to fix the security issues.
+4. If applicable, explain the fix and how it resolves the vulnerability."""
+
+_APPLY_INSTRUCTIONS = """## Your task
+
+You are running on the user's own machine inside their checkout of this
+repository. Apply the security fixes directly to the files in the current
+working directory.
+
+Guidelines:
+1. Fix the findings above, prioritising CRITICAL and HIGH severity first.
+2. For dependency CVEs, bump the affected package to the listed fixed version
+   in the appropriate manifest/lockfile. Do not upgrade unrelated packages.
+3. For detected secrets, remove the secret from source and replace it with an
+   environment variable or secret-manager reference. Never invent a real value.
+4. Make the smallest change that resolves each finding. Do not refactor
+   unrelated code, reformat files, or change behaviour beyond the fix.
+5. If a finding cannot be safely auto-fixed, leave the code unchanged and note
+   why in your summary instead of guessing.
+6. Do not commit, push, or open a pull request unless explicitly asked — just
+   edit the working tree and leave the changes staged for the user to review.
+
+When done, print a concise summary of every file you changed and which finding
+each change addresses."""
+
+
+def build_fix_prompt(
+    results: dict,
+    label: str,
+    mode: str = "advise",
+    extra_instruction: Optional[str] = None,
+) -> str:
+    """Build the markdown fix prompt fed to an LLM or local coding agent.
+
+    Args:
+        results: Scan-results payload (already may contain sensitive fields;
+            they are stripped here).
+        label: Human-readable repo/path label for the heading.
+        mode: ``"advise"`` (suggest changes only — legacy ``--prompt`` output) or
+            ``"apply"`` (instruct a local agent to edit files in place).
+        extra_instruction: Optional caller-supplied instruction appended to the end.
+
+    Returns:
+        The prompt as a string.
+    """
+    prompt_data = _prompt_scan_data(results or {})
+
+    parts = [
+        f"# Prismor Security Scan Results for {label}\n",
+        "## Scan Data\n",
+        "```json",
+        json.dumps(prompt_data, indent=2),
+        "```\n",
+        _APPLY_INSTRUCTIONS if mode == "apply" else _ADVISE_INSTRUCTIONS,
+    ]
+    if extra_instruction:
+        parts.append(f"\n## Additional instruction from the user\n{extra_instruction}")
+    return "\n".join(parts)