py-opencode-wrapper 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

opencode_wrapper/client.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import os
 import shutil
 import tempfile
@@ -12,6 +13,7 @@ from pathlib import Path
 from typing import Any, AsyncIterator, Mapping
 
 from opencode_wrapper.config import RunConfig, validate_config_for_run
+from opencode_wrapper.config import loads_jsonc, sanitize_user_config_json
 from opencode_wrapper.errors import (
     OpenCodeBinaryNotFoundError,
     OpenCodeProcessError,
@@ -158,6 +160,96 @@ def _is_sqlite_startup_error(stderr: str) -> bool:
     return any(pat in lower for pat in _SQLITE_STARTUP_PATTERNS)
 
 
+_LOG = logging.getLogger(__name__)
+
+# Filenames opencode reads from its global config dir + ~/.opencode.
+# Legacy TOML ("config" without extension) is intentionally skipped — it's rare
+# and would require a TOML parser dep; the wrapper aims for stdlib-only.
+_GLOBAL_CONFIG_FILENAMES: tuple[str, ...] = (
+    "config.json",
+    "opencode.json",
+    "opencode.jsonc",
+)
+
+
+def _resolve_real_xdg_config_opencode_dir(env: Mapping[str, str]) -> Path:
+    xdg = env.get("XDG_CONFIG_HOME")
+    base = Path(xdg).expanduser() if xdg else Path(env.get("HOME", str(Path.home()))).expanduser() / ".config"
+    return base / "opencode"
+
+
+def _resolve_real_home_opencode_dir(env: Mapping[str, str]) -> Path:
+    return Path(env.get("HOME", str(Path.home()))).expanduser() / ".opencode"
+
+
+def _sanitize_and_copy(src_dir: Path, dst_dir: Path) -> None:
+    """Read each known opencode config file in *src_dir*, sanitize, write to *dst_dir*.
+
+    Strict JSON files parse on the fast path; JSONC (comments, trailing commas)
+    falls back to ``loads_jsonc``.  Files that aren't valid in either form are
+    skipped with a warning — for benchmark reproducibility the wrapper would
+    rather hide a file it can't safely strip than risk leaking capability keys.
+    Missing source files are silently skipped.  ``dst_dir`` is always created
+    so opencode finds the directory (even if empty).
+    """
+    from opencode_wrapper.config import sanitize_user_config_json
+
+    dst_dir.mkdir(parents=True, exist_ok=True)
+    if not src_dir.is_dir():
+        return
+    for fname in _GLOBAL_CONFIG_FILENAMES:
+        src = src_dir / fname
+        if not src.is_file():
+            continue
+        try:
+            text = src.read_text(encoding="utf-8")
+        except OSError as exc:
+            _LOG.warning("user-config isolation: cannot read %s: %s", src, exc)
+            continue
+        try:
+            raw = loads_jsonc(text)
+        except json.JSONDecodeError as exc:
+            _LOG.warning(
+                "user-config isolation: skipping %s (not parseable as JSON or JSONC): %s",
+                src, exc,
+            )
+            continue
+        if not isinstance(raw, dict):
+            _LOG.warning(
+                "user-config isolation: skipping %s (root is not a JSON object)", src
+            )
+            continue
+        sanitized = sanitize_user_config_json(raw)
+        (dst_dir / fname).write_text(
+            json.dumps(sanitized, ensure_ascii=False), encoding="utf-8"
+        )
+
+
+def _isolate_user_config(env: dict[str, str], tmp_root: Path) -> dict[str, str]:
+    """Mutate *env* so opencode sees a sanitized copy of the user's global config.
+
+    Reads the real ``$XDG_CONFIG_HOME/opencode`` and ``$HOME/.opencode``,
+    filters each file through ``sanitize_user_config_json`` (keeping only
+    ``provider`` / ``disabled_providers`` / ``enabled_providers`` / ``$schema``),
+    writes the results under *tmp_root*, and points ``XDG_CONFIG_HOME`` /
+    ``OPENCODE_TEST_HOME`` at those tmpdir locations.  Strips
+    ``OPENCODE_CONFIG`` / ``OPENCODE_CONFIG_DIR`` so the parent shell can't
+    re-introduce extras.  Project-level config (cwd walk + ``.opencode/``)
+    is untouched.
+    """
+    iso_xdg = tmp_root / "xdg"
+    iso_home = tmp_root / "home"
+
+    _sanitize_and_copy(_resolve_real_xdg_config_opencode_dir(env), iso_xdg / "opencode")
+    _sanitize_and_copy(_resolve_real_home_opencode_dir(env), iso_home / ".opencode")
+
+    env["XDG_CONFIG_HOME"] = str(iso_xdg)
+    env["OPENCODE_TEST_HOME"] = str(iso_home)
+    env.pop("OPENCODE_CONFIG", None)
+    env.pop("OPENCODE_CONFIG_DIR", None)
+    return env
+
+
 class AsyncOpenCodeClient:
     """
     One-shot async wrapper around the OpenCode CLI.
@@ -207,13 +299,16 @@ class AsyncOpenCodeClient:
         argv: list[str],
         cwd: str,
         env: dict[str, str],
+        run_cfg: RunConfig,
     ) -> AsyncIterator[tuple[asyncio.subprocess.Process, list[str]]]:
         stderr_lines: list[str] = []
+        cleanup_tmpdirs: list[str] = []
         # Give each process its own XDG_DATA_HOME so opencode.db is isolated.
         # Without this, all concurrent processes share ~/.local/share/opencode/opencode.db
         # and SQLite write locks during tool execution serialize the runs (37–46s delays).
         if self._isolate_db:
             xdg_tmpdir = tempfile.mkdtemp(prefix="oc_xdg_")
+            cleanup_tmpdirs.append(xdg_tmpdir)
             # Symlink auth.json so provider API keys (stored by `opencode auth`)
             # are visible in the isolated data dir.  Without this, providers
             # that rely on auth.json (rather than env-var keys) fail with
@@ -225,8 +320,16 @@ class AsyncOpenCodeClient:
                 iso_oc_dir.mkdir(parents=True, exist_ok=True)
                 (iso_oc_dir / "auth.json").symlink_to(real_auth)
             env = {**env, "XDG_DATA_HOME": xdg_tmpdir}
-        else:
-            xdg_tmpdir = None
+        # When the caller has not opted into host-config inheritance (the
+        # default), redirect XDG_CONFIG_HOME / OPENCODE_TEST_HOME at a sanitized
+        # tmpdir copy of the user's global config — only provider settings are
+        # carried over, all capability keys (mcp / agent / command / tools /
+        # plugin / skills / instructions / permission / model / ...) are stripped.
+        # Project-level config (cwd walk + .opencode/) is untouched.
+        if not run_cfg.inherit_user_config:
+            cfg_tmpdir = tempfile.mkdtemp(prefix="oc_cfg_")
+            cleanup_tmpdirs.append(cfg_tmpdir)
+            env = _isolate_user_config(dict(env), Path(cfg_tmpdir))
         # Serialise process startup to avoid the SQLite WAL-pragma race.
         # The semaphore is released as soon as the startup window has elapsed,
         # so all processes run concurrently after their individual delay.
@@ -257,8 +360,8 @@ class AsyncOpenCodeClient:
                 await stderr_task
             except asyncio.CancelledError:
                 pass
-            if xdg_tmpdir is not None:
-                shutil.rmtree(xdg_tmpdir, ignore_errors=True)
+            for path in cleanup_tmpdirs:
+                shutil.rmtree(path, ignore_errors=True)
 
     async def async_stream(
         self,
@@ -283,7 +386,7 @@ class AsyncOpenCodeClient:
         events_acc: list[dict[str, Any]] = []
         raw_acc: list[str] = []
 
-        async with self._managed_process(argv, cwd, env) as (proc, stderr_lines):
+        async with self._managed_process(argv, cwd, env, run_cfg) as (proc, stderr_lines):
             async for line, ev in _stdout_line_event_iter(proc):
                 raw_acc.append(line)
                 events_acc.append(ev)
@@ -341,7 +444,7 @@ class AsyncOpenCodeClient:
 
             log_fh = open(log_file, "w") if log_file is not None else None
             try:
-                async with self._managed_process(argv, cwd, env) as (proc, stderr_lines):
+                async with self._managed_process(argv, cwd, env, run_cfg) as (proc, stderr_lines):
                     async for line, ev in _stdout_line_event_iter(proc):
                         raw_acc.append(line)
                         events_acc.append(ev)

opencode_wrapper/config.py

@@ -13,6 +13,107 @@ PermissionAction = str  # "allow" | "ask" | "deny"
 # Nested permission maps: tool name -> action or pattern -> action
 PermissionMap = Dict[str, Any]
 
+# Top-level keys retained from the host's global opencode config when
+# inherit_user_config=False.  Everything else (mcp / agent / command / skills /
+# plugin / tools / instructions / permission / model / ...) is dropped to make
+# benchmark runs reproducible.
+PRESERVE_KEYS: frozenset[str] = frozenset(
+    {
+        "$schema",
+        "provider",
+        "disabled_providers",
+        "enabled_providers",
+    }
+)
+
+
+def sanitize_user_config_json(raw: Mapping[str, Any]) -> dict[str, Any]:
+    """Filter a parsed opencode config dict to the benchmark-safe preserve set.
+
+    Only ``PRESERVE_KEYS`` survive; everything else — including capability keys
+    like ``mcp`` / ``agent`` / ``command`` / ``tools`` / ``plugin`` / ``skills``
+    and the default ``model`` — is removed.  Benchmark callers re-inject the
+    bits they need via ``RunConfig``.
+    """
+    return {k: v for k, v in raw.items() if k in PRESERVE_KEYS}
+
+
+def strip_jsonc(source: str) -> str:
+    """Convert a JSONC source string to strict JSON.
+
+    Supports the JSONC superset accepted by opencode (and VS Code's
+    jsonc-parser): ``//`` line comments, ``/* ... */`` block comments, and
+    trailing commas in objects/arrays.  Strings — including ones that contain
+    ``//`` or ``/*`` — are preserved verbatim, with backslash escape sequences
+    handled.  Unterminated block comments swallow the rest of the input.
+
+    Stdlib-only — keeps the wrapper's zero-runtime-deps invariant.
+    """
+    out: list[str] = []
+    i = 0
+    n = len(source)
+    while i < n:
+        c = source[i]
+        # JSON string: copy verbatim, handle escapes
+        if c == '"':
+            out.append(c)
+            i += 1
+            while i < n:
+                cc = source[i]
+                out.append(cc)
+                if cc == "\\" and i + 1 < n:
+                    out.append(source[i + 1])
+                    i += 2
+                    continue
+                i += 1
+                if cc == '"':
+                    break
+            continue
+        # Line comment: drop through newline (keep newline for line accuracy)
+        if c == "/" and i + 1 < n and source[i + 1] == "/":
+            nl = source.find("\n", i + 2)
+            i = n if nl == -1 else nl
+            continue
+        # Block comment: drop through closing */
+        if c == "/" and i + 1 < n and source[i + 1] == "*":
+            end = source.find("*/", i + 2)
+            i = n if end == -1 else end + 2
+            continue
+        # Possible trailing comma: peek ahead past whitespace/comments
+        if c == ",":
+            j = i + 1
+            while j < n:
+                cj = source[j]
+                if cj.isspace():
+                    j += 1
+                elif cj == "/" and j + 1 < n and source[j + 1] == "/":
+                    nl = source.find("\n", j + 2)
+                    j = n if nl == -1 else nl
+                elif cj == "/" and j + 1 < n and source[j + 1] == "*":
+                    end = source.find("*/", j + 2)
+                    j = n if end == -1 else end + 2
+                else:
+                    break
+            if j < n and source[j] in "}]":
+                i += 1  # drop the trailing comma
+                continue
+        out.append(c)
+        i += 1
+    return "".join(out)
+
+
+def loads_jsonc(source: str) -> Any:
+    """Parse a JSON or JSONC string, falling back to JSONC stripping on failure.
+
+    The fast path is plain ``json.loads`` — most files are strict JSON.
+    On failure we strip JSONC syntax and retry once.  The caller catches
+    ``json.JSONDecodeError`` if even the stripped form is invalid.
+    """
+    try:
+        return json.loads(source)
+    except json.JSONDecodeError:
+        return json.loads(strip_jsonc(source))
+
 
 def _deep_merge(base: dict[str, Any], override: Mapping[str, Any]) -> dict[str, Any]:
     out = dict(base)
@@ -50,6 +151,7 @@ class RunConfig:
     print_logs: bool | None = None
     log_level: str | None = None
     disable_autoupdate: bool = True
+    inherit_user_config: bool = False
     extra_env: Mapping[str, str] | None = None
     # Injected as JSON via OPENCODE_CONFIG_CONTENT (merged with config_overrides)
     permission: PermissionMap | None = None

{py_opencode_wrapper-0.1.5.dist-info → py_opencode_wrapper-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-opencode-wrapper
-Version: 0.1.5
+Version: 0.2.0
 Summary: Async Python wrapper for OpenCode CLI (opencode run --format json)
 Project-URL: Homepage, https://github.com/idailylife/oc_py_wrapper
 Project-URL: Repository, https://github.com/idailylife/oc_py_wrapper

py_opencode_wrapper-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+opencode_wrapper/__init__.py,sha256=iCkMcrh7P35jHFq8gH-GKjaKqwnvmOkGCLRfgnb0moE,1013
+opencode_wrapper/client.py,sha256=TDDCHCRb2WGk4Pipb2nJLLhWt2nz43wYsreKvSYl9EQ,19003
+opencode_wrapper/config.py,sha256=JraBPkX95GXFoOvn181BRv_8YPvsUDXiZMN1hZWhSf0,7823
+opencode_wrapper/errors.py,sha256=zaXzzFb6ObdrNlm-PJE_7tbgvMEhoZcbeQVWNHNTkUQ,1168
+opencode_wrapper/events.py,sha256=PHz04DcB0K0JfIRxgV8GQ3psl7VjQXZ25gIrDCOgAHQ,6478
+py_opencode_wrapper-0.2.0.dist-info/METADATA,sha256=Tw2pl9daegsqTvvx0RIciN2idvIhYzVPQIHORVmWoEI,5940
+py_opencode_wrapper-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+py_opencode_wrapper-0.2.0.dist-info/top_level.txt,sha256=8LETj5bPgl1YnB83iOiueuQvGryj3RzaeEQecPVS9Q8,17
+py_opencode_wrapper-0.2.0.dist-info/RECORD,,

py_opencode_wrapper-0.1.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-opencode_wrapper/__init__.py,sha256=iCkMcrh7P35jHFq8gH-GKjaKqwnvmOkGCLRfgnb0moE,1013
-opencode_wrapper/client.py,sha256=wVVxBHyYey-uqwRn4Q6QKazWNOJ3gXrN-ltO5W66CqM,14523
-opencode_wrapper/config.py,sha256=7vWlWpkewWIxzQnAHtetgw4YN6xPj9Bw0IkwuO4CjaY,4046
-opencode_wrapper/errors.py,sha256=zaXzzFb6ObdrNlm-PJE_7tbgvMEhoZcbeQVWNHNTkUQ,1168
-opencode_wrapper/events.py,sha256=PHz04DcB0K0JfIRxgV8GQ3psl7VjQXZ25gIrDCOgAHQ,6478
-py_opencode_wrapper-0.1.5.dist-info/METADATA,sha256=eYf9t9WvqVAN3eHmhdU7W-Rvi5O0OyMZ1DQKFU6suEI,5940
-py_opencode_wrapper-0.1.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-py_opencode_wrapper-0.1.5.dist-info/top_level.txt,sha256=8LETj5bPgl1YnB83iOiueuQvGryj3RzaeEQecPVS9Q8,17
-py_opencode_wrapper-0.1.5.dist-info/RECORD,,