py-opencode-wrapper 0.1.5__py3-none-any.whl → 0.2.1__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,
@@ -79,7 +81,12 @@ def build_argv(
     return cmd
 
 
-def build_env(run_cfg: RunConfig, base: Mapping[str, str] | None = None) -> dict[str, str]:
+def build_env(
+    run_cfg: RunConfig,
+    base: Mapping[str, str] | None = None,
+    *,
+    cwd: str | Path | None = None,
+) -> dict[str, str]:
     env = dict(base if base is not None else os.environ)
     if run_cfg.extra_env:
         env.update(dict(run_cfg.extra_env))
@@ -88,6 +95,14 @@ def build_env(run_cfg: RunConfig, base: Mapping[str, str] | None = None) -> dict
         env["OPENCODE_CONFIG_CONTENT"] = content
     if run_cfg.disable_autoupdate:
         env["OPENCODE_DISABLE_AUTOUPDATE"] = "1"
+    # opencode's `run` cmd resolves the project root as
+    # `process.env.PWD ?? process.cwd()` (run.ts:276), and the bash builtin
+    # `pwd` reads $PWD too.  asyncio.create_subprocess_exec(cwd=...) only
+    # chdirs the child; it leaves PWD inherited from the parent shell, which
+    # makes opencode operate against the wrong directory.  Pin PWD to the
+    # resolved workspace so the child sees a consistent cwd.
+    if cwd is not None:
+        env["PWD"] = str(cwd)
     return env
 
 
@@ -158,6 +173,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 +312,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 +333,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 +373,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,
@@ -277,13 +393,13 @@ class AsyncOpenCodeClient:
         validate_config_for_run(run_cfg)
         bin_path = self.resolved_binary()
         argv = build_argv(bin_path, prompt, run_cfg)
-        env = build_env(run_cfg)
         cwd = str(Path(workspace).expanduser().resolve())
+        env = build_env(run_cfg, cwd=cwd)
 
         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)
@@ -333,15 +449,15 @@ class AsyncOpenCodeClient:
             validate_config_for_run(run_cfg)
             bin_path = self.resolved_binary()
             argv = build_argv(bin_path, prompt, run_cfg)
-            env = build_env(run_cfg)
             cwd = str(Path(workspace).expanduser().resolve())
+            env = build_env(run_cfg, cwd=cwd)
 
             events_acc: list[dict[str, Any]] = []
             raw_acc: list[str] = []
 
             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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-opencode-wrapper
-Version: 0.1.5
+Version: 0.2.1
 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
@@ -104,11 +104,29 @@ Per-call JSON is merged and passed as `OPENCODE_CONFIG_CONTENT` (see [OpenCode c
 | `permission` | `permission` map (`allow` / `deny`, patterns) |
 | `mcp` | MCP server definitions |
 | `tools` | Enable/disable tools (including MCP globs) |
+| `instructions` | Instruction file paths / glob patterns to inject |
 | `config_overrides` | Any extra top-level config keys to deep-merge |
 
 Optional env tuning: `disable_autoupdate=True` sets `OPENCODE_DISABLE_AUTOUPDATE=1`.
 Note: `ask` is intentionally rejected in subprocess mode (no interactive terminal); use `allow` or `deny`.
 
+### User config isolation
+
+By default, `RunConfig.inherit_user_config=False` makes each child `opencode`
+process see a sanitized copy of the host's global OpenCode config. The wrapper
+keeps only provider-selection keys (`$schema`, `provider`,
+`disabled_providers`, `enabled_providers`) and drops capability/configuration
+keys such as `mcp`, `agent`, `command`, `tools`, `plugin`, `skills`,
+`instructions`, `permission`, and `model`.
+
+This keeps benchmark and orchestration runs reproducible while still allowing
+provider configuration and `opencode auth` credentials to work. Project-level
+config discovered from the workspace is not suppressed.
+
+Set `inherit_user_config=True` to restore the legacy behavior of inheriting the
+host OpenCode config as-is. For reproducible runs, pass `model`, `permission`,
+`mcp`, `tools`, and `instructions` explicitly through `RunConfig`.
+
 ## CLI arguments
 
 `RunConfig` maps to flags such as `--agent`, `-m`, `-f`, `--attach`, `--title`, etc. Prompt text is appended as the final `opencode run` message argument.

py_opencode_wrapper-0.2.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+opencode_wrapper/__init__.py,sha256=iCkMcrh7P35jHFq8gH-GKjaKqwnvmOkGCLRfgnb0moE,1013
+opencode_wrapper/client.py,sha256=Ny4pDBV6cToIOn2W7BgCFL1w12KdlVQVCInhddf_Df4,19546
+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.1.dist-info/METADATA,sha256=W56IyS4yoBlsSFIIrtsPx0-Ck6AoCCuhmdHiZslRgnE,6884
+py_opencode_wrapper-0.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+py_opencode_wrapper-0.2.1.dist-info/top_level.txt,sha256=8LETj5bPgl1YnB83iOiueuQvGryj3RzaeEQecPVS9Q8,17
+py_opencode_wrapper-0.2.1.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,,