open-code-review-toolkit 0.3.0__tar.gz → 0.3.1__tar.gz

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-code-review-toolkit
-Version: 0.3.0
+Version: 0.3.1
 Summary: Unofficial GitLab CI integration layer for Open Code Review
 Project-URL: Homepage, https://github.com/xeonvs/open-code-review-toolkit
 Project-URL: Repository, https://github.com/xeonvs/open-code-review-toolkit
@@ -243,7 +243,7 @@ ocr --version
 ocr-ci --help
 ```
 
-The current compatibility target is OCR `1.7.17`. CI should pin the release and verify its published checksum before execution.
+The current compatibility target is OCR `1.8.0`. CI should pin the release and verify its published checksum before execution.
 The [versioned compatibility policy](docs/compatibility.md) records tested assets and evidence and describes the conservative Dependabot-like qualification workflow for later upstream releases.
 Review output defaults to English. Set `OCR_REVIEW_LANGUAGE=Russian` to use Russian consistently in both OCR configuration and generated review context.
 
@@ -277,7 +277,7 @@ ocr-ci preflight
 ocr-ci configure
 ocr-ci mcp-config
 ocr-ci context --output .review-context/dependencies.md
-# run: ocr review ... --format json
+ocr-ci review --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log -- ... --format json
 ocr-ci post --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log
 ```
 

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/README.md

@@ -15,7 +15,7 @@ ocr --version
 ocr-ci --help
 ```
 
-The current compatibility target is OCR `1.7.17`. CI should pin the release and verify its published checksum before execution.
+The current compatibility target is OCR `1.8.0`. CI should pin the release and verify its published checksum before execution.
 The [versioned compatibility policy](docs/compatibility.md) records tested assets and evidence and describes the conservative Dependabot-like qualification workflow for later upstream releases.
 Review output defaults to English. Set `OCR_REVIEW_LANGUAGE=Russian` to use Russian consistently in both OCR configuration and generated review context.
 
@@ -49,7 +49,7 @@ ocr-ci preflight
 ocr-ci configure
 ocr-ci mcp-config
 ocr-ci context --output .review-context/dependencies.md
-# run: ocr review ... --format json
+ocr-ci review --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log -- ... --format json
 ocr-ci post --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log
 ```
 

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/src/ocr_toolkit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
 
 __commit_id__ = commit_id = None

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/src/ocr_toolkit/cli.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import argparse
+import sys
 from collections.abc import Sequence
+from pathlib import Path
 
-from ocr_toolkit import configure, mcp_config, preflight
+from ocr_toolkit import configure, mcp_config, preflight, review_runner
 from ocr_toolkit.context import render as context_render
 from ocr_toolkit.posting.workflow import main as posting_main
 
@@ -21,6 +23,14 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers.add_parser("preflight", help="Validate OCR, GitLab, and LLM access.")
     subparsers.add_parser("configure", help="Write the OCR runtime configuration.")
     subparsers.add_parser("mcp-config", help="Write OCR MCP server configuration.")
+    review_parser = subparsers.add_parser(
+        "review", help="Run OCR with private artifacts and safe failure diagnostics."
+    )
+    review_parser.add_argument("--result", required=True, help="OCR JSON output path.")
+    review_parser.add_argument("--stderr", required=True, help="Full OCR stderr artifact path.")
+    review_parser.add_argument(
+        "ocr_args", nargs=argparse.REMAINDER, help="OCR review arguments after --."
+    )
 
     context_parser = subparsers.add_parser(
         "context", help="Generate bounded repository review context."
@@ -57,6 +67,13 @@ def main(argv: Sequence[str] | None = None) -> int:
         return configure.main()
     if args.command == "mcp-config":
         return mcp_config.configure_mcp_servers()
+    if args.command == "review":
+        ocr_args = args.ocr_args[1:] if args.ocr_args[:1] == ["--"] else args.ocr_args
+        try:
+            return review_runner.run_review(Path(args.result), Path(args.stderr), ocr_args)
+        except review_runner.ReviewRunnerError as exc:
+            print(f"Cannot run Open Code Review: {exc}", file=sys.stderr)
+            return 2
     if args.command == "context":
         return context_render.main(["--output", args.output])
     if args.command == "post":

open_code_review_toolkit-0.3.1/src/ocr_toolkit/mcp_config.py

@@ -0,0 +1,479 @@
+"""Configure OCR MCP servers from CI environment variables."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import urllib.parse
+from dataclasses import dataclass
+from typing import Any
+
+from ocr_toolkit.common.redaction import redact_sensitive
+from ocr_toolkit.config_writer import OCRConfigError, read_ocr_config, update_ocr_config
+
+MAX_MCP_CONFIG_BYTES = 64_000
+MAX_MCP_SERVERS = 16
+MAX_MCP_ARGS = 64
+MAX_MCP_ENV = 64
+MAX_MCP_HEADERS = 32
+MAX_MCP_TOOLS = 128
+MAX_MCP_URL_CHARS = 2_048
+MAX_MCP_HEADER_VALUE_CHARS = 2_048
+MAX_MCP_SETUP_CHARS = 4_096
+MAX_MCP_STRING_CHARS = 4_096
+MCP_NAME_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+MCP_ENV_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+MCP_HEADER_NAME_RE = re.compile(r"^[!#$%&'*+.^_`|~0-9A-Za-z-]+$")
+SENSITIVE_HEADER_NAME_RE = re.compile(
+    r"(?:^|[-_])(?:authorization|authentication|auth|cookie|api[-_]?key|"
+    r"subscription[-_]?key|key|token|secret|credential)(?:$|[-_])",
+    flags=re.IGNORECASE,
+)
+TRUE_VALUES = {"1", "true", "yes", "on"}
+FALSE_VALUES = {"0", "false", "no", "off", ""}
+
+
+class MCPConfigError(Exception):
+    """The MCP CI configuration is invalid."""
+
+
+@dataclass(frozen=True)
+class MCPServerConfig:
+    """Validated OCR MCP server configuration for one transport."""
+
+    name: str
+    transport: str
+    command: str | None
+    url: str | None
+    args: list[str]
+    tools: list[str]
+    setup: str
+    env: list[str]
+    headers: dict[str, str]
+    secret_values: list[str]
+
+
+def _string_list(value: Any, field: str, *, limit: int) -> list[str]:
+    """Validate one bounded JSON string list and preserve its order."""
+
+    if not isinstance(value, list):
+        raise MCPConfigError(f"{field} must be a JSON array of strings")
+    if len(value) > limit:
+        raise MCPConfigError(f"{field} exceeds maximum item count {limit}")
+    result: list[str] = []
+    for index, item in enumerate(value):
+        if not isinstance(item, str):
+            raise MCPConfigError(f"{field}[{index}] must be a string")
+        if len(item) > MAX_MCP_STRING_CHARS:
+            raise MCPConfigError(f"{field}[{index}] exceeds maximum length {MAX_MCP_STRING_CHARS}")
+        result.append(item)
+    return result
+
+
+def _env_assignments(value: Any, env_from: Any, server_name: str) -> tuple[list[str], list[str]]:
+    """Build stdio environment assignments and collect values for redaction."""
+
+    assignments: list[str] = []
+    secret_values: list[str] = []
+
+    if value is None:
+        value = {}
+    if env_from is None:
+        env_from = {}
+    if not isinstance(value, dict):
+        raise MCPConfigError(f"servers.{server_name}.env must be an object")
+    if not isinstance(env_from, dict):
+        raise MCPConfigError(f"servers.{server_name}.env_from must be an object")
+    if len(value) + len(env_from) > MAX_MCP_ENV:
+        raise MCPConfigError(
+            f"servers.{server_name}.env/env_from exceed maximum item count {MAX_MCP_ENV}"
+        )
+
+    for key, item in value.items():
+        if not isinstance(key, str) or not MCP_ENV_NAME_RE.fullmatch(key):
+            raise MCPConfigError(f"servers.{server_name}.env contains invalid env name")
+        if not isinstance(item, str):
+            raise MCPConfigError(f"servers.{server_name}.env.{key} must be a string")
+        if len(key) + len(item) + 1 > MAX_MCP_STRING_CHARS:
+            raise MCPConfigError(
+                f"servers.{server_name}.env.{key} exceeds maximum length {MAX_MCP_STRING_CHARS}"
+            )
+        assignments.append(f"{key}={item}")
+
+    for key, source_name in env_from.items():
+        if not isinstance(key, str) or not MCP_ENV_NAME_RE.fullmatch(key):
+            raise MCPConfigError(f"servers.{server_name}.env_from contains invalid env name")
+        if key in value:
+            raise MCPConfigError(
+                f"servers.{server_name}.env_from.{key} duplicates servers.{server_name}.env.{key}"
+            )
+        if not isinstance(source_name, str) or not MCP_ENV_NAME_RE.fullmatch(source_name):
+            raise MCPConfigError(f"servers.{server_name}.env_from.{key} must name a CI variable")
+        if source_name not in os.environ:
+            raise MCPConfigError(
+                f"servers.{server_name}.env_from.{key} references missing CI variable {source_name}"
+            )
+        secret_value = os.environ[source_name]
+        assignments.append(f"{key}={secret_value}")
+        if secret_value:
+            secret_values.append(secret_value)
+
+    return assignments, secret_values
+
+
+def _validate_header_name(name: Any, field: str) -> str:
+    """Return an HTTP token header name or reject the input."""
+
+    if not isinstance(name, str) or not MCP_HEADER_NAME_RE.fullmatch(name):
+        raise MCPConfigError(f"{field} contains an invalid HTTP header name")
+    return name
+
+
+def _headers(value: Any, env_from: Any, server_name: str) -> tuple[dict[str, str], list[str]]:
+    """Project bounded literal and environment-backed headers into OCR syntax."""
+
+    if value is None:
+        value = {}
+    if env_from is None:
+        env_from = {}
+    if not isinstance(value, dict):
+        raise MCPConfigError(f"servers.{server_name}.headers must be an object")
+    if not isinstance(env_from, dict):
+        raise MCPConfigError(f"servers.{server_name}.headers_from must be an object")
+    if len(value) + len(env_from) > MAX_MCP_HEADERS:
+        raise MCPConfigError(
+            f"servers.{server_name}.headers/headers_from exceed maximum item count "
+            f"{MAX_MCP_HEADERS}"
+        )
+
+    result: dict[str, str] = {}
+    normalized_names: set[str] = set()
+    secret_values: list[str] = []
+    for raw_name, item in value.items():
+        name = _validate_header_name(raw_name, f"servers.{server_name}.headers")
+        normalized = name.casefold()
+        if normalized in normalized_names:
+            raise MCPConfigError(f"servers.{server_name} contains duplicate HTTP header {name!r}")
+        normalized_names.add(normalized)
+        # Literal credentials would be copied into both CI input and OCR's on-disk
+        # config. Sensitive header families must cross this boundary only through
+        # an environment-variable reference.
+        if SENSITIVE_HEADER_NAME_RE.search(name):
+            raise MCPConfigError(
+                f"servers.{server_name}.headers.{name} is sensitive; use headers_from"
+            )
+        if not isinstance(item, str):
+            raise MCPConfigError(f"servers.{server_name}.headers.{name} must be a string")
+        if not item or len(item) > MAX_MCP_HEADER_VALUE_CHARS:
+            raise MCPConfigError(
+                f"servers.{server_name}.headers.{name} must be non-empty and at most "
+                f"{MAX_MCP_HEADER_VALUE_CHARS} characters"
+            )
+        if any(ord(char) < 0x20 or ord(char) == 0x7F for char in item):
+            raise MCPConfigError(
+                f"servers.{server_name}.headers.{name} contains invalid control characters"
+            )
+        result[name] = item
+
+    for raw_name, source_name in env_from.items():
+        name = _validate_header_name(raw_name, f"servers.{server_name}.headers_from")
+        normalized = name.casefold()
+        if normalized in normalized_names:
+            raise MCPConfigError(f"servers.{server_name} contains duplicate HTTP header {name!r}")
+        normalized_names.add(normalized)
+        if not isinstance(source_name, str) or not MCP_ENV_NAME_RE.fullmatch(source_name):
+            raise MCPConfigError(
+                f"servers.{server_name}.headers_from.{name} must name a CI variable"
+            )
+        secret_value = os.environ.get(source_name)
+        if not secret_value:
+            raise MCPConfigError(
+                f"servers.{server_name}.headers_from.{name} references missing or empty CI "
+                f"variable {source_name}"
+            )
+        if len(secret_value) > MAX_MCP_HEADER_VALUE_CHARS:
+            raise MCPConfigError(
+                f"servers.{server_name}.headers_from.{name} references a CI variable "
+                f"exceeding {MAX_MCP_HEADER_VALUE_CHARS} characters"
+            )
+        if any(ord(char) < 0x20 or ord(char) == 0x7F for char in secret_value):
+            raise MCPConfigError(
+                f"servers.{server_name}.headers_from.{name} references a CI variable "
+                "containing invalid HTTP control characters"
+            )
+        # OCR 1.8 expands $VARNAME when it creates the remote client. Keeping the
+        # reference avoids serializing the secret into config.json. Read the value
+        # once so missing credentials fail early and downstream errors can redact it.
+        result[name] = f"${source_name}"
+        secret_values.append(secret_value)
+
+    return result, secret_values
+
+
+def _remote_url(value: Any, server_name: str) -> str:
+    """Validate a bounded HTTPS Streamable HTTP endpoint for OCR."""
+
+    if not isinstance(value, str) or not value or len(value) > MAX_MCP_URL_CHARS:
+        raise MCPConfigError(
+            f"servers.{server_name}.url must be a non-empty HTTPS URL of at most "
+            f"{MAX_MCP_URL_CHARS} characters"
+        )
+    if any(ord(char) < 0x20 or ord(char) == 0x7F for char in value):
+        raise MCPConfigError(f"servers.{server_name}.url contains invalid control characters")
+    try:
+        parsed = urllib.parse.urlsplit(value)
+        port = parsed.port
+    except ValueError as exc:
+        raise MCPConfigError(f"servers.{server_name}.url is not a valid HTTPS URL") from exc
+    # OCR accepts plain HTTP, but the toolkit's CI contract is stricter because
+    # credentials can traverse this endpoint. Userinfo and fragments are rejected
+    # because they add leak-prone ambiguity; queries are accepted but never logged.
+    if (
+        parsed.scheme != "https"
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.fragment
+        or (port is not None and not 1 <= port <= 65_535)
+    ):
+        raise MCPConfigError(
+            f"servers.{server_name}.url must be absolute HTTPS without userinfo or fragment"
+        )
+    return value
+
+
+def parse_mcp_servers(raw: str | None = None) -> list[MCPServerConfig]:
+    """Return bounded stdio and remote configs from OCR_MCP_SERVERS_JSON."""
+
+    raw = os.environ.get("OCR_MCP_SERVERS_JSON", "") if raw is None else raw
+    raw = raw.strip()
+    if not raw:
+        return []
+    if len(raw.encode("utf-8")) > MAX_MCP_CONFIG_BYTES:
+        raise MCPConfigError(f"OCR_MCP_SERVERS_JSON exceeds {MAX_MCP_CONFIG_BYTES} bytes")
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise MCPConfigError(
+            "OCR_MCP_SERVERS_JSON is not valid JSON; check CI variable formatting"
+        ) from exc
+    except RecursionError as exc:
+        raise MCPConfigError("OCR_MCP_SERVERS_JSON is too deeply nested") from exc
+
+    if not isinstance(payload, dict):
+        raise MCPConfigError("OCR_MCP_SERVERS_JSON top-level value must be an object")
+    if "servers" in payload:
+        if len(payload) != 1:
+            raise MCPConfigError(
+                "OCR_MCP_SERVERS_JSON cannot mix the servers envelope with named servers"
+            )
+        servers_value = payload["servers"]
+        if not isinstance(servers_value, list):
+            raise MCPConfigError("OCR_MCP_SERVERS_JSON.servers must be an array")
+    else:
+        servers_value = []
+        for name, value in payload.items():
+            if not isinstance(value, dict):
+                raise MCPConfigError(f"OCR MCP server {name!r} configuration must be an object")
+            if "name" in value and value["name"] != name:
+                raise MCPConfigError(f"OCR MCP server {name!r} must not declare a different name")
+            servers_value.append({**value, "name": name})
+    if len(servers_value) > MAX_MCP_SERVERS:
+        raise MCPConfigError(f"OCR_MCP_SERVERS_JSON has more than {MAX_MCP_SERVERS} servers")
+
+    seen: set[str] = set()
+    servers: list[MCPServerConfig] = []
+    for index, server in enumerate(servers_value):
+        if not isinstance(server, dict):
+            raise MCPConfigError(f"servers[{index}] must be an object")
+        enabled = server.get("enabled", True)
+        if not isinstance(enabled, bool):
+            raise MCPConfigError(f"servers[{index}].enabled must be a boolean")
+        if enabled is False:
+            continue
+
+        name = server.get("name")
+        if not isinstance(name, str) or not MCP_NAME_RE.fullmatch(name):
+            raise MCPConfigError(f"servers[{index}].name is invalid")
+        if name in seen:
+            raise MCPConfigError(f"duplicate MCP server name {name!r}")
+        seen.add(name)
+        transport = server.get("type", "stdio")
+        if transport not in {"stdio", "remote"}:
+            raise MCPConfigError(f"servers.{name}.type must be 'stdio' or 'remote'")
+        common_fields = {"name", "type", "enabled", "tools", "setup"}
+        transport_fields = (
+            {"command", "args", "env", "env_from"}
+            if transport == "stdio"
+            else {"url", "headers", "headers_from"}
+        )
+        unknown_fields = set(server) - common_fields - transport_fields
+        if unknown_fields:
+            fields = ", ".join(sorted(unknown_fields))
+            raise MCPConfigError(f"servers.{name} has unsupported fields for {transport}: {fields}")
+
+        tools = _string_list(server.get("tools", []), f"servers.{name}.tools", limit=MAX_MCP_TOOLS)
+        setup = server.get("setup", "")
+        if not isinstance(setup, str):
+            raise MCPConfigError(f"servers.{name}.setup must be a string")
+        if len(setup) > MAX_MCP_SETUP_CHARS:
+            raise MCPConfigError(
+                f"servers.{name}.setup exceeds maximum length {MAX_MCP_SETUP_CHARS}"
+            )
+
+        command: str | None = None
+        url: str | None = None
+        args: list[str] = []
+        env: list[str] = []
+        headers: dict[str, str] = {}
+        secret_values: list[str] = []
+        if transport == "stdio":
+            command_value = server.get("command")
+            if not isinstance(command_value, str) or not command_value.strip():
+                raise MCPConfigError(f"servers.{name}.command must be a non-empty string")
+            command = command_value.strip()
+            if len(command) > MAX_MCP_STRING_CHARS:
+                raise MCPConfigError(
+                    f"servers.{name}.command exceeds maximum length {MAX_MCP_STRING_CHARS}"
+                )
+            args = _string_list(server.get("args", []), f"servers.{name}.args", limit=MAX_MCP_ARGS)
+            env, secret_values = _env_assignments(server.get("env"), server.get("env_from"), name)
+        else:
+            url = _remote_url(server.get("url"), name)
+            headers, secret_values = _headers(
+                server.get("headers"), server.get("headers_from"), name
+            )
+        servers.append(
+            MCPServerConfig(
+                name=name,
+                transport=transport,
+                command=command,
+                url=url,
+                args=args,
+                tools=tools,
+                setup=setup,
+                env=env,
+                headers=headers,
+                secret_values=secret_values,
+            )
+        )
+
+    return servers
+
+
+def _replace_configured_servers() -> bool:
+    """Return whether generated servers replace, rather than merge with, OCR state."""
+
+    value = os.environ.get("OCR_MCP_REPLACE", "false").strip().lower()
+    if value in TRUE_VALUES:
+        return True
+    if value in FALSE_VALUES:
+        return False
+    raise MCPConfigError("OCR_MCP_REPLACE must be a boolean (true/false, 1/0, yes/no, or on/off)")
+
+
+def _redact_extra_values(text: str, values: list[str]) -> str:
+    """Redact raw and URL-encoded secret variants from an error string."""
+
+    redacted = text
+    for value in values:
+        if value and len(value) >= 4:
+            for variant in {
+                value,
+                urllib.parse.quote(value, safe=""),
+                urllib.parse.quote_plus(value, safe=""),
+            }:
+                if variant:
+                    redacted = redacted.replace(variant, "***")
+    return redacted
+
+
+def configure_mcp_servers() -> int:
+    """Configure OCR MCP servers from CI and return a process exit code."""
+
+    try:
+        servers = parse_mcp_servers()
+        replace = _replace_configured_servers()
+    except MCPConfigError as exc:
+        print(f"Invalid OCR MCP configuration: {redact_sensitive(str(exc))}", file=sys.stderr)
+        return 1
+
+    if not servers:
+        try:
+            if replace:
+                update_ocr_config({"mcp_servers": {}})
+        except OCRConfigError as exc:
+            print(
+                f"Failed to clear OCR MCP servers: {redact_sensitive(str(exc))}",
+                file=sys.stderr,
+            )
+            return 1
+        if replace:
+            print("OCR MCP servers: none configured; existing servers cleared")
+        else:
+            print("OCR MCP servers: none configured; existing servers preserved")
+        return 0
+
+    mcp_servers: dict[str, Any] = {}
+    secret_values: list[str] = []
+    for server in servers:
+        if server.transport == "stdio":
+            mcp_servers[server.name] = {
+                "type": "stdio",
+                "command": server.command,
+                "args": server.args,
+                "env": server.env,
+                "tools": server.tools,
+                "setup": server.setup,
+            }
+        else:
+            mcp_servers[server.name] = {
+                "type": "remote",
+                "url": server.url,
+                "headers": server.headers,
+                "tools": server.tools,
+                "setup": server.setup,
+            }
+        secret_values.extend(server.secret_values)
+        for assignment in server.env:
+            _env_name, _sep, env_value = assignment.partition("=")
+            if env_value:
+                secret_values.append(env_value)
+
+    try:
+        if not replace:
+            # update_ocr_config replaces the complete mcp_servers object. Preserve
+            # unrelated entries here, before its atomic private-permission write.
+            existing = read_ocr_config().get("mcp_servers", {})
+            if existing is None:
+                existing = {}
+            if not isinstance(existing, dict):
+                raise OCRConfigError("OCR config mcp_servers value is not an object")
+            mcp_servers = {**existing, **mcp_servers}
+        update_ocr_config({"mcp_servers": mcp_servers})
+    except OCRConfigError as exc:
+        print(
+            "Failed to configure OCR MCP servers: "
+            f"{redact_sensitive(_redact_extra_values(str(exc), secret_values))}",
+            file=sys.stderr,
+        )
+        return 1
+
+    for server in servers:
+        if server.transport == "stdio":
+            detail = f"args={len(server.args)} env={len(server.env)}"
+        else:
+            detail = f"headers={len(server.headers)}"
+        print(
+            f"OCR MCP server configured: {server.name} type={server.transport} "
+            f"{detail} tools={len(server.tools)}"
+        )
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(configure_mcp_servers())

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/src/ocr_toolkit/posting/workflow.py

@@ -62,6 +62,7 @@ from ocr_toolkit.posting.settings import (
     post_mode,
     strict_posting,
 )
+from ocr_toolkit.review_runner import read_stderr_excerpt
 
 
 def finalize_posting(config: GitLabConfig, draft_note_ids: list[int]) -> bool:
@@ -709,33 +710,6 @@ def post_llm_provider_failure(
     return 1
 
 
-STDERR_PROBE_BYTES = 64 * 1024
-
-
-def read_stderr_excerpt(stderr_path: Path, max_chars: int = 4000) -> str:
-    """Read a bounded, redacted excerpt of an OCR stderr log.
-
-    Reads at most STDERR_PROBE_BYTES so a multi-megabyte stderr does
-    not stress the runner memory. Redaction runs on the full probe
-    BEFORE truncation so a secret bisected by the char limit is still
-    matched against its full environment-value form.
-    """
-
-    if not stderr_path.exists():
-        return ""
-
-    try:
-        with stderr_path.open("rb") as handle:
-            chunk = handle.read(STDERR_PROBE_BYTES)
-    except OSError:
-        return ""
-
-    text = chunk.decode("utf-8", errors="replace").strip()
-    if not text:
-        return ""
-    return redact_sensitive(text)[:max_chars]
-
-
 def post_parse_error(config: GitLabConfig, stderr_path: Path) -> int:
     """Post a safe error note when OCR output is not valid JSON.
 

{open_code_review_toolkit-0.3.0 → open_code_review_toolkit-0.3.1}/src/ocr_toolkit/preflight.py

@@ -24,7 +24,7 @@ DEFAULT_REQUEST_HEADERS = {
     "Accept": "application/json",
     "User-Agent": "open-code-review-ci-preflight/1.0",
 }
-EXPECTED_OCR_VERSION = "1.7.17"
+EXPECTED_OCR_VERSION = "1.8.0"
 
 
 class PreflightError(Exception):

open_code_review_toolkit-0.3.1/src/ocr_toolkit/review_runner.py

@@ -0,0 +1,117 @@
+"""Run Open Code Review with private artifacts and safe CI diagnostics."""
+
+from __future__ import annotations
+
+import os
+import stat
+import subprocess
+import sys
+from contextlib import ExitStack
+from io import BufferedWriter
+from pathlib import Path
+
+from ocr_toolkit.common.redaction import redact_sensitive
+
+STDERR_PROBE_BYTES = 64 * 1024
+DEFAULT_DIAGNOSTIC_CHARS = 4_000
+
+
+class ReviewRunnerError(Exception):
+    """The local OCR review process could not be started safely."""
+
+
+def _open_private_artifact(path: Path, label: str) -> BufferedWriter:
+    """Open one regular artifact without following a final-component symlink."""
+
+    flags = os.O_CREAT | os.O_WRONLY
+    if hasattr(os, "O_NOFOLLOW"):
+        # The pre-check gives a clear error; O_NOFOLLOW closes the replacement race
+        # between that check and open on platforms that expose the flag.
+        flags |= os.O_NOFOLLOW
+    if hasattr(os, "O_NONBLOCK"):
+        # Opening a pre-created FIFO for writing could otherwise block the CI job
+        # before the descriptor can be rejected as a non-artifact sink.
+        flags |= os.O_NONBLOCK
+    descriptor = -1
+    try:
+        descriptor = os.open(path, flags, 0o600)
+        file_stat = os.fstat(descriptor)
+        if not stat.S_ISREG(file_stat.st_mode):
+            raise ReviewRunnerError(f"private {label} artifact must be a regular file: {path}")
+        if file_stat.st_nlink > 1:
+            raise ReviewRunnerError(f"private {label} artifact must not have hard links: {path}")
+        os.fchmod(descriptor, 0o600)
+        # Delay truncation until the descriptor has passed type and link checks.
+        os.ftruncate(descriptor, 0)
+    except ReviewRunnerError:
+        if descriptor >= 0:
+            os.close(descriptor)
+        raise
+    except OSError as exc:
+        if descriptor >= 0:
+            os.close(descriptor)
+        raise ReviewRunnerError(f"could not open private {label} artifact: {exc}") from exc
+    return open(descriptor, "wb", closefd=True)
+
+
+def read_stderr_excerpt(stderr_path: Path, max_chars: int = DEFAULT_DIAGNOSTIC_CHARS) -> str:
+    """Read a bounded, redacted excerpt of an OCR stderr artifact."""
+
+    if not stderr_path.exists():
+        return ""
+    try:
+        with stderr_path.open("rb") as handle:
+            chunk = handle.read(STDERR_PROBE_BYTES)
+    except OSError:
+        return ""
+
+    text = chunk.decode("utf-8", errors="replace").strip()
+    if not text:
+        return ""
+    # Redact before truncation so a secret crossing the display boundary is
+    # matched against its complete environment value or credential pattern.
+    return redact_sensitive(text)[:max_chars]
+
+
+def run_review(result_path: Path, stderr_path: Path, ocr_args: list[str]) -> int:
+    """Execute `ocr review`, retain private artifacts, and report safe failures."""
+
+    if not ocr_args:
+        raise ReviewRunnerError("at least one OCR review argument is required after --")
+    if result_path.absolute() == stderr_path.absolute():
+        raise ReviewRunnerError("result and stderr paths must be different")
+    for path, label in ((result_path, "result"), (stderr_path, "stderr")):
+        if path.is_symlink():
+            raise ReviewRunnerError(f"{label} path must not be a symlink: {path}")
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+    # Use explicit argv and file descriptors: OCR-controlled output never crosses
+    # a shell, while umask 077 keeps both artifacts private on shared runners.
+    previous_umask = os.umask(0o077)
+    try:
+        with ExitStack() as stack:
+            result_file = stack.enter_context(_open_private_artifact(result_path, "result"))
+            stderr_file = stack.enter_context(_open_private_artifact(stderr_path, "stderr"))
+            if os.path.samestat(os.fstat(result_file.fileno()), os.fstat(stderr_file.fileno())):
+                raise ReviewRunnerError("result and stderr paths must be different")
+            completed = subprocess.run(
+                ["ocr", "review", *ocr_args],
+                check=False,
+                stdin=subprocess.DEVNULL,
+                stdout=result_file,
+                stderr=stderr_file,
+            )
+    except OSError as exc:
+        raise ReviewRunnerError(f"could not execute OCR: {exc}") from exc
+    finally:
+        os.umask(previous_umask)
+
+    if completed.returncode != 0:
+        print(f"Open Code Review exited with code {completed.returncode}.", file=sys.stderr)
+        excerpt = read_stderr_excerpt(stderr_path)
+        if excerpt:
+            print("Safe OCR stderr excerpt:", file=sys.stderr)
+            print(excerpt, file=sys.stderr)
+        else:
+            print("OCR did not provide a readable stderr diagnostic.", file=sys.stderr)
+    return completed.returncode

open_code_review_toolkit-0.3.0/src/ocr_toolkit/mcp_config.py

@@ -1,257 +0,0 @@
-"""Configure OCR MCP servers from CI environment variables."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import sys
-import urllib.parse
-from dataclasses import dataclass
-from typing import Any
-
-from ocr_toolkit.common.redaction import redact_sensitive
-from ocr_toolkit.config_writer import OCRConfigError, update_ocr_config
-
-MAX_MCP_CONFIG_BYTES = 64_000
-MAX_MCP_SERVERS = 16
-MAX_MCP_ARGS = 64
-MAX_MCP_ENV = 64
-MAX_MCP_TOOLS = 128
-MCP_NAME_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
-MCP_ENV_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
-
-
-class MCPConfigError(Exception):
-    """The MCP CI configuration is invalid."""
-
-
-@dataclass(frozen=True)
-class MCPServerConfig:
-    """Validated OCR MCP server configuration for one stdio bridge."""
-
-    name: str
-    command: str
-    args: list[str]
-    tools: list[str]
-    setup: str
-    env: list[str]
-    secret_values: list[str]
-
-
-def _string_list(value: Any, field: str, *, limit: int) -> list[str]:
-    if not isinstance(value, list):
-        raise MCPConfigError(f"{field} must be a JSON array of strings")
-    if len(value) > limit:
-        raise MCPConfigError(f"{field} exceeds maximum item count {limit}")
-    result: list[str] = []
-    for index, item in enumerate(value):
-        if not isinstance(item, str):
-            raise MCPConfigError(f"{field}[{index}] must be a string")
-        result.append(item)
-    return result
-
-
-def _env_assignments(value: Any, env_from: Any, server_name: str) -> tuple[list[str], list[str]]:
-    assignments: list[str] = []
-    secret_values: list[str] = []
-
-    if value is None:
-        value = {}
-    if env_from is None:
-        env_from = {}
-    if not isinstance(value, dict):
-        raise MCPConfigError(f"servers.{server_name}.env must be an object")
-    if not isinstance(env_from, dict):
-        raise MCPConfigError(f"servers.{server_name}.env_from must be an object")
-    if len(value) + len(env_from) > MAX_MCP_ENV:
-        raise MCPConfigError(
-            f"servers.{server_name}.env/env_from exceed maximum item count {MAX_MCP_ENV}"
-        )
-
-    for key, item in value.items():
-        if not isinstance(key, str) or not MCP_ENV_NAME_RE.fullmatch(key):
-            raise MCPConfigError(f"servers.{server_name}.env contains invalid env name")
-        if not isinstance(item, str):
-            raise MCPConfigError(f"servers.{server_name}.env.{key} must be a string")
-        assignments.append(f"{key}={item}")
-
-    for key, source_name in env_from.items():
-        if not isinstance(key, str) or not MCP_ENV_NAME_RE.fullmatch(key):
-            raise MCPConfigError(f"servers.{server_name}.env_from contains invalid env name")
-        if key in value:
-            raise MCPConfigError(
-                f"servers.{server_name}.env_from.{key} duplicates servers.{server_name}.env.{key}"
-            )
-        if not isinstance(source_name, str) or not MCP_ENV_NAME_RE.fullmatch(source_name):
-            raise MCPConfigError(f"servers.{server_name}.env_from.{key} must name a CI variable")
-        if source_name not in os.environ:
-            raise MCPConfigError(
-                f"servers.{server_name}.env_from.{key} references missing CI variable {source_name}"
-            )
-        secret_value = os.environ[source_name]
-        assignments.append(f"{key}={secret_value}")
-        if secret_value:
-            secret_values.append(secret_value)
-
-    return assignments, secret_values
-
-
-def parse_mcp_servers(raw: str | None = None) -> list[MCPServerConfig]:
-    """Return validated MCP server configs from OCR_MCP_SERVERS_JSON."""
-
-    raw = os.environ.get("OCR_MCP_SERVERS_JSON", "") if raw is None else raw
-    raw = raw.strip()
-    if not raw:
-        return []
-    if len(raw.encode("utf-8")) > MAX_MCP_CONFIG_BYTES:
-        raise MCPConfigError(f"OCR_MCP_SERVERS_JSON exceeds {MAX_MCP_CONFIG_BYTES} bytes")
-
-    try:
-        payload = json.loads(raw)
-    except json.JSONDecodeError as exc:
-        raise MCPConfigError(
-            "OCR_MCP_SERVERS_JSON is not valid JSON; check CI variable formatting"
-        ) from exc
-    except RecursionError as exc:
-        raise MCPConfigError("OCR_MCP_SERVERS_JSON is too deeply nested") from exc
-
-    if not isinstance(payload, dict):
-        raise MCPConfigError("OCR_MCP_SERVERS_JSON top-level value must be an object")
-    if "servers" in payload:
-        if len(payload) != 1:
-            raise MCPConfigError(
-                "OCR_MCP_SERVERS_JSON cannot mix the servers envelope with named servers"
-            )
-        servers_value = payload["servers"]
-        if not isinstance(servers_value, list):
-            raise MCPConfigError("OCR_MCP_SERVERS_JSON.servers must be an array")
-    else:
-        servers_value = []
-        for name, value in payload.items():
-            if not isinstance(value, dict):
-                raise MCPConfigError(f"OCR MCP server {name!r} configuration must be an object")
-            if "name" in value and value["name"] != name:
-                raise MCPConfigError(f"OCR MCP server {name!r} must not declare a different name")
-            servers_value.append({**value, "name": name})
-    if len(servers_value) > MAX_MCP_SERVERS:
-        raise MCPConfigError(f"OCR_MCP_SERVERS_JSON has more than {MAX_MCP_SERVERS} servers")
-
-    seen: set[str] = set()
-    servers: list[MCPServerConfig] = []
-    for index, server in enumerate(servers_value):
-        if not isinstance(server, dict):
-            raise MCPConfigError(f"servers[{index}] must be an object")
-        enabled = server.get("enabled", True)
-        if not isinstance(enabled, bool):
-            raise MCPConfigError(f"servers[{index}].enabled must be a boolean")
-        if enabled is False:
-            continue
-
-        name = server.get("name")
-        if not isinstance(name, str) or not MCP_NAME_RE.fullmatch(name):
-            raise MCPConfigError(f"servers[{index}].name is invalid")
-        if name in seen:
-            raise MCPConfigError(f"duplicate MCP server name {name!r}")
-        seen.add(name)
-
-        command = server.get("command")
-        if not isinstance(command, str) or not command.strip():
-            raise MCPConfigError(f"servers.{name}.command must be a non-empty string")
-        command = command.strip()
-
-        args = _string_list(server.get("args", []), f"servers.{name}.args", limit=MAX_MCP_ARGS)
-        tools = _string_list(server.get("tools", []), f"servers.{name}.tools", limit=MAX_MCP_TOOLS)
-        setup = server.get("setup", "")
-        if not isinstance(setup, str):
-            raise MCPConfigError(f"servers.{name}.setup must be a string")
-
-        env, secret_values = _env_assignments(server.get("env"), server.get("env_from"), name)
-        servers.append(
-            MCPServerConfig(
-                name=name,
-                command=command,
-                args=args,
-                tools=tools,
-                setup=setup,
-                env=env,
-                secret_values=secret_values,
-            )
-        )
-
-    return servers
-
-
-def _redact_extra_values(text: str, values: list[str]) -> str:
-    redacted = text
-    for value in values:
-        if value and len(value) >= 4:
-            for variant in {
-                value,
-                urllib.parse.quote(value, safe=""),
-                urllib.parse.quote_plus(value, safe=""),
-            }:
-                if variant:
-                    redacted = redacted.replace(variant, "***")
-    return redacted
-
-
-def configure_mcp_servers() -> int:
-    """Configure OCR MCP servers from CI and return a process exit code."""
-
-    try:
-        servers = parse_mcp_servers()
-    except MCPConfigError as exc:
-        print(f"Invalid OCR_MCP_SERVERS_JSON: {redact_sensitive(str(exc))}", file=sys.stderr)
-        return 1
-
-    if not servers:
-        try:
-            update_ocr_config({"mcp_servers": {}})
-        except OCRConfigError as exc:
-            print(
-                f"Failed to clear OCR MCP servers: {redact_sensitive(str(exc))}",
-                file=sys.stderr,
-            )
-            return 1
-        print("OCR MCP servers: none configured")
-        return 0
-
-    mcp_servers: dict[str, Any] = {}
-    secret_values: list[str] = []
-    for server in servers:
-        mcp_servers[server.name] = {
-            "command": server.command,
-            "args": server.args,
-            "env": server.env,
-            "tools": server.tools,
-            "setup": server.setup,
-        }
-        secret_values.extend(server.secret_values)
-        for assignment in server.env:
-            _env_name, _sep, env_value = assignment.partition("=")
-            if env_value:
-                secret_values.append(env_value)
-
-    try:
-        update_ocr_config({"mcp_servers": mcp_servers})
-    except OCRConfigError as exc:
-        print(
-            "Failed to configure OCR MCP servers: "
-            f"{redact_sensitive(_redact_extra_values(str(exc), secret_values))}",
-            file=sys.stderr,
-        )
-        return 1
-
-    for server in servers:
-        print(
-            "OCR MCP server configured: "
-            f"{server.name} command={server.command!r} "
-            f"args={len(server.args)} env={len(server.env)} tools={len(server.tools)}"
-        )
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(configure_mcp_servers())