optio-opencode 0.1.4__tar.gz → 0.1.6__tar.gz

{optio_opencode-0.1.4 → optio_opencode-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.1.4
+Version: 0.1.6
 Summary: Run opencode web as an optio task; local subprocess or remote via SSH.
 Author-email: Kristof Csillag <kristof.csillag@deai-labs.com>
 License-Expression: Apache-2.0

{optio_opencode-0.1.4 → optio_opencode-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "optio-opencode"
-version = "0.1.4"
+version = "0.1.6"
 description = "Run opencode web as an optio task; local subprocess or remote via SSH."
 readme = "README.md"
 license = "Apache-2.0"

{optio_opencode-0.1.4 → optio_opencode-0.1.6}/src/optio_opencode/__init__.py

@@ -14,6 +14,13 @@ from optio_opencode.types import (
     HookCallback,
     OpencodeTaskConfig,
 )
+from optio_opencode.seed_manifest import (
+    OPENCODE_SEED_MANIFEST,
+    OPENCODE_SEED_SUFFIX,
+    delete_seed,
+    list_seeds,
+    purge_seed,
+)
 
 # asyncssh emits per-connection / per-channel INFO lines ("Opening SSH
 # connection...", "Received channel close", etc.) that flood the worker's
@@ -34,4 +41,9 @@ __all__ = [
     "HostCommandError",
     "RunResult",
     "HookCallback",
+    "OPENCODE_SEED_MANIFEST",
+    "OPENCODE_SEED_SUFFIX",
+    "delete_seed",
+    "list_seeds",
+    "purge_seed",
 ]

{optio_opencode-0.1.4 → optio_opencode-0.1.6}/src/optio_opencode/host_actions.py

@@ -9,8 +9,10 @@ Install path is uniform: ``ensure_opencode_installed`` drives
 csillag/opencode's ``smart-install.sh --check`` and, when needed, downloads
 the release zip as an optio child task (`HookContext.download_file`),
 unpacks it on the host, and places the binary at
-``<install_dir>/opencode``. ``install_dir`` defaults to
-``~/.local/bin`` (resolved per host) and is overridable via the
+``<install_dir>/opencode``. ``install_dir`` defaults to the optio-owned
+binary cache on the worker
+(``OPENCODE_CACHE_DIR`` / ``${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin``,
+resolved per host — never the host home bin dir) and is overridable via the
 ``install_dir`` keyword argument on the public entry points; consumers
 expose this as ``OpencodeTaskConfig.opencode_install_dir``.
 No isinstance branches.
@@ -36,23 +38,53 @@ _SMART_INSTALL_URL = (
     "https://raw.githubusercontent.com/csillag/opencode/main/smart-install.sh"
 )
 
-# Sub-path of the host's $HOME used as the default opencode install
-# directory when no explicit ``install_dir`` is supplied. Kept as a
-# constant so the three places that care about it (smart-install PATH
-# augmentation, post-ok ``command -v`` lookup, ``_install_opencode_from_zip``
-# install target) stay in agreement.
-DEFAULT_INSTALL_SUBDIR = ".local/bin"
+# The optio-owned opencode binary cache lives on the WORKER, never in the host
+# user's home bin dir. Default cache:
+# ``${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin``, overridable via the
+# ``OPENCODE_CACHE_DIR`` env var on the worker. Kept as a constant so the places
+# that care about it (smart-install PATH augmentation, post-ok ``command -v``
+# lookup, ``_install_opencode_from_zip`` install target) stay in agreement.
+_OPENCODE_CACHE_SHELL_DEFAULT = (
+    '${OPENCODE_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin}'
+)
 
 
 async def _resolve_install_dir(host: "Host", install_dir: str | None) -> str:
-    """Return ``install_dir`` if given, else the host's default install dir.
+    """Resolve the opencode binary-cache dir as an absolute path on the worker.
 
-    Default: ``<host_home>/<DEFAULT_INSTALL_SUBDIR>``.
-    """
+    ``install_dir`` (config.opencode_install_dir) overrides. Else the worker's
+    OPENCODE_CACHE_DIR / XDG_CACHE_HOME / $HOME decide it — resolved via a shell
+    echo so RemoteHost gets the remote cache. Resolved from the worker's REAL env
+    (this runs before per-task XDG isolation), so the cache stays shared and
+    outside any workdir → never snapshotted; evictable → smart-install re-downloads."""
     if install_dir is not None:
-        return install_dir
-    host_home = await host.resolve_host_home()
-    return f"{host_home}/{DEFAULT_INSTALL_SUBDIR}"
+        return install_dir.rstrip("/")
+    r = await host.run_command(f'printf %s "{_OPENCODE_CACHE_SHELL_DEFAULT}"')
+    path = r.stdout.strip()
+    if r.exit_code != 0 or not path:
+        raise RuntimeError(
+            f"failed to resolve opencode cache dir on host (exit {r.exit_code}): "
+            f"{r.stderr.strip()[:200]}"
+        )
+    return path.rstrip("/")
+
+
+def _isolation_env(host: "Host") -> dict[str, str]:
+    """Per-task HOME/XDG isolation env, derived from ``host.workdir``.
+
+    Merged into the launch env AND the export/import env so opencode's
+    auth/config/data go per-task under ``<workdir>/home`` (where the seed
+    manifest's ``home_subdir`` and merge/capture target). Distinct from the
+    binary cache (``_resolve_install_dir``), which is shared and resolved from
+    the worker's REAL env before this isolation applies.
+    """
+    home = f"{host.workdir.rstrip('/')}/home"
+    return {
+        "HOME": home,
+        "XDG_CONFIG_HOME": f"{home}/.config",
+        "XDG_DATA_HOME": f"{home}/.local/share",
+        "XDG_CACHE_HOME": f"{home}/.cache",
+    }
 
 
 def _path_augmented(cmd: str, install_dir: str) -> str:
@@ -61,9 +93,9 @@ def _path_augmented(cmd: str, install_dir: str) -> str:
     Used so smart-install's internal ``command -v opencode`` and the
     post-"ok" lookup find the binary at the install location even when
     the calling shell's PATH doesn't already include it (common: the
-    python process inherits a slimmed-down PATH that doesn't add
-    ``~/.local/bin``, so smart-install would falsely report "download"
-    and we'd reinstall on every task run).
+    python process inherits a slimmed-down PATH that doesn't add the
+    optio-owned opencode binary cache dir, so smart-install would falsely
+    report "download" and we'd reinstall on every task run).
     """
     return f'export PATH={shlex.quote(install_dir)}:"$PATH"; {cmd}'
 
@@ -80,8 +112,9 @@ async def _smart_install_check(
 
     ``install_dir`` is prepended to PATH inside the remote shell so
     smart-install's internal ``command -v opencode`` can see binaries
-    installed by a prior ``_install_opencode_from_zip``. Defaults to
-    ``~/.local/bin`` on the host.
+    installed by a prior ``_install_opencode_from_zip``. Defaults to the
+    optio-owned opencode binary cache on the worker (see
+    ``_resolve_install_dir``).
 
     Raises RuntimeError on non-zero exit or unparseable output.
     """
@@ -124,7 +157,8 @@ async def _install_opencode_from_zip(
       4. mkdir -p ``install_dir``; move binary there; chmod +x.
       5. Remove the tempdir.
 
-    ``install_dir`` defaults to ``~/.local/bin`` on the host when None.
+    ``install_dir`` defaults to the optio-owned opencode binary cache on
+    the worker when None (see ``_resolve_install_dir``).
 
     Returns the absolute install path on the host.
     """
@@ -194,7 +228,9 @@ async def ensure_opencode_installed(
 
     ``install_dir`` is the absolute path of the directory that holds (or
     will hold) the ``opencode`` binary on the host. When None (default),
-    resolves to ``<host_home>/.local/bin``. Pass an explicit absolute path
+    resolves to the optio-owned binary cache on the worker
+    (``OPENCODE_CACHE_DIR`` / ``${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin``;
+    see ``_resolve_install_dir``). Pass an explicit absolute path
     to opt out of the default — the same dir is used for installation, for
     smart-install's PATH lookup, and for the post-"ok" ``command -v``
     resolution, so all three stay in agreement.
@@ -278,7 +314,7 @@ async def opencode_import(
     try:
         result = await host.run_command(
             f"bash -lc {shlex.quote(opencode_executable + ' import ' + shlex.quote(scratch))}",
-            env={"OPENCODE_DB": opencode_db_path},
+            env={**_isolation_env(host), "OPENCODE_DB": opencode_db_path},
         )
         if result.exit_code != 0:
             raise RuntimeError(
@@ -310,7 +346,7 @@ async def opencode_export(
         result = await host.run_command(
             f"bash -lc "
             f"{shlex.quote(opencode_executable + ' export ' + shlex.quote(session_id) + ' > ' + shlex.quote(scratch))}",
-            env={"OPENCODE_DB": opencode_db_path},
+            env={**_isolation_env(host), "OPENCODE_DB": opencode_db_path},
         )
         if result.exit_code != 0:
             raise RuntimeError(
@@ -329,6 +365,7 @@ async def launch_opencode(
     ready_timeout_s: float = 30.0,
     opencode_executable: str = "opencode",
     hostname: str = "127.0.0.1",
+    extra_env: dict[str, str] | None = None,
 ) -> tuple[ProcessHandle, int]:
     """Launch ``opencode web`` on ``host``; wait for the listening URL.
 
@@ -336,10 +373,10 @@ async def launch_opencode(
     and references it via ``$(cat ...)`` in the launch command so the
     literal value never appears on the remote process's argv.
 
-    Lays down no-op browser-opener stubs (xdg-open, gio, open,
-    sensible-browser) under ``<workdir>/bin`` and prepends that
-    directory to PATH so opencode's automatic browser-launch is
-    suppressed.
+    Browser-open suppression is handled by the optio-agents protocol
+    driver (``get_protocol(browser="suppress")``), which installs no-op
+    opener stubs under ``<workdir>/bin`` and returns the ``BROWSER`` /
+    ``PATH`` env additions; the caller passes those in via ``extra_env``.
 
     ``hostname`` is passed to ``opencode web --hostname=`` so callers
     can bind to a non-loopback interface when consumers reach the server
@@ -354,48 +391,38 @@ async def launch_opencode(
     await host.write_text(pw_file, password)
     await host.run_command(f"chmod 600 {host.workdir}/{pw_file}")
 
-    # Browser-suppression bin shadow.
-    for noop in ("xdg-open", "gio", "open", "sensible-browser"):
-        await host.write_text(f"bin/{noop}", "#!/bin/sh\nexit 0\n")
-    chmod_result = await host.run_command(f"chmod +x {host.workdir}/bin/*")
-    if chmod_result.exit_code != 0:
-        # Non-fatal: the noop scripts may fail to be executable, but worst
-        # case opencode tries to open a browser and we just live with it.
-        pass
-
-    # Build cmd: read password from file via $(cat), set BROWSER=true,
-    # cd to workdir so opencode picks up opencode.json.
+    # Build cmd: read password from file via $(cat), cd to workdir so
+    # opencode picks up opencode.json. Browser suppression (the BROWSER
+    # env + the <workdir>/bin PATH prepend that shadows the openers) comes
+    # from the protocol driver's suppress shims, passed in via extra_env.
     #
     # NOTE: do NOT wrap in `bash -lc` / `bash -l`. A login shell sources
     # the user's profile (~/.profile, ~/.bash_profile, /etc/profile),
     # which on most Linux installs rewrites PATH from scratch and
-    # therefore wipes the workdir/bin prefix we set in `env` below. With
-    # the prefix gone, the noop xdg-open / sensible-browser / gio / open
-    # shadows below stop hiding the real ones and opencode succeeds at
-    # opening a real browser window. opencode_executable is an absolute
-    # path (resolved by ensure_opencode_installed), so login-shell PATH
-    # lookup is not needed to find the binary. Let LocalHost / RemoteHost
-    # launch_subprocess do the shell wrapping; we just need the env-var
-    # prefix and $(cat ...) substitution, which any POSIX sh handles.
+    # therefore wipes the workdir/bin prefix carried in `env` below. With
+    # the prefix gone, the suppress stubs stop hiding the real openers and
+    # opencode succeeds at opening a real browser window. opencode_executable
+    # is an absolute path (resolved by ensure_opencode_installed), so
+    # login-shell PATH lookup is not needed to find the binary.
     cmd = (
         f"exec env "
         f"OPENCODE_SERVER_PASSWORD=\"$(cat {shlex.quote(host.workdir + '/' + pw_file)})\" "
-        f"BROWSER=true "
         f"{opencode_executable} web --port=0 --hostname={shlex.quote(hostname)}"
     )
 
-    # Prepend the noop-browsers bin dir to PATH via env on launch_subprocess.
-    workdir_bin = f"{host.workdir}/bin"
-    extra_path = workdir_bin + ":" + os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin")
     # OPENCODE_DB must point at the same per-task db file used by the
     # subsequent export/import CLI calls. Without this, the server falls
     # back to opencode's global default db while export/import target the
     # taskdir-local file — causing snapshot capture to "Session not found"
     # against an empty file. Convention: opencode.db is a sibling of the
     # workdir under taskdir (session.py: opencode_db = f"{taskdir}/opencode.db").
+    # The browser-suppression env (PATH prepend + BROWSER) comes from extra_env.
+    # The HOME/XDG isolation env (from _isolation_env) points opencode's
+    # auth/config/data at <workdir>/home so per-task seeding works.
     env = {
-        "PATH": extra_path,
+        **_isolation_env(host),
         "OPENCODE_DB": f"{host.taskdir}/opencode.db",
+        **(extra_env or {}),
     }
 
     handle = await host.launch_subprocess(cmd, env=env, cwd=host.workdir)

{optio_opencode-0.1.4 → optio_opencode-0.1.6}/src/optio_opencode/prompt.py

@@ -7,7 +7,7 @@ addressed. The consumer's own task description is then appended verbatim.
 """
 
 
-from optio_agents.protocol.prompt import LOG_CHANNEL_PROMPT
+from optio_agents.protocol import build_log_channel_prompt
 
 
 _OPENCODE_INTRO = """# Coordination protocol with the host (optio-opencode)
@@ -18,9 +18,6 @@ throughout the session.
 """
 
 
-BASE_PROMPT_PRE = _OPENCODE_INTRO + LOG_CHANNEL_PROMPT
-
-
 BASE_PROMPT_POST = """## Task
 
 Here comes the description of your actual task to complete. Throughout
@@ -120,6 +117,7 @@ def compose_agents_md(
     consumer_instructions: str,
     *,
     workdir_exclude: list[str] | None,
+    documentation: str | None = None,
     supports_resume: bool = True,
 ) -> str:
     """Build the full AGENTS.md body.
@@ -130,12 +128,18 @@ def compose_agents_md(
         callers must pass it explicitly to prevent silent desync between
         archive.py defaults and the prompt's claims about what's preserved.
         Pass None to render with the framework defaults.
+      documentation: the keyword-protocol block; the session passes
+        ``get_protocol(browser="suppress").documentation``. Defaults (for
+        unit tests / standalone callers) to opencode's ``suppress`` docs.
       supports_resume: when False, the resume-detection section is omitted
         from the prompt. Default True.
     """
+    if documentation is None:
+        documentation = build_log_channel_prompt("suppress")
+    base_prompt_pre = _OPENCODE_INTRO + documentation
     body = consumer_instructions.rstrip()
     if supports_resume:
         resume_block = _render_resume_section(workdir_exclude) + "\n"
     else:
         resume_block = ""
-    return f"{BASE_PROMPT_PRE}\n{resume_block}{BASE_PROMPT_POST}\n{body}\n"
+    return f"{base_prompt_pre}\n{resume_block}{BASE_PROMPT_POST}\n{body}\n"

optio_opencode-0.1.6/src/optio_opencode/seed_manifest.py

@@ -0,0 +1,61 @@
+"""opencode adopter of the generic optio-agents seed engine.
+
+Defines the opencode seed manifest (HOME layout + capture-time include
+triage), the Mongo collection suffix, and ergonomic `delete_seed` /
+`list_seeds` / `purge_seed` wrappers that bind the suffix for consuming
+apps.
+
+Unlike claudecode, opencode needs no consume-time rekey: its auth/config
+are cwd-independent, so `consume_transform` is None.
+"""
+
+from __future__ import annotations
+
+from optio_agents import seeds
+
+OPENCODE_SEED_SUFFIX = "_opencode_seeds"
+OPENCODE_SEED_MANIFEST_VERSION = 1
+
+
+OPENCODE_SEED_MANIFEST = seeds.SeedManifest(
+    home_subdir="home",
+    include=[
+        ".local/share/opencode/auth.json",
+        ".config/opencode/opencode.json",
+        ".config/opencode/plugins",
+    ],
+    version=OPENCODE_SEED_MANIFEST_VERSION,
+    consume_transform=None,  # no cwd-rekey for opencode
+)
+
+
+async def delete_seed(store, seed_id: str):
+    """Delete an opencode seed doc; returns its GridFS blobId (or None).
+
+    Takes an optio store binding (``optio.store`` — exposes ``db`` and
+    ``prefix``) as-is, so consuming apps hand over the whole namespace handle
+    instead of threading db+prefix (or knowing the collection suffix). The
+    caller still removes the returned blob from GridFS.
+    """
+    return await seeds.delete_seed(
+        store.db, prefix=store.prefix, suffix=OPENCODE_SEED_SUFFIX, seed_id=seed_id,
+    )
+
+
+async def list_seeds(store) -> list[dict]:
+    """List opencode seeds as [{seedId, createdAt}, ...]. Takes an optio store
+    binding (``optio.store``) as-is."""
+    return await seeds.list_seeds(store.db, prefix=store.prefix, suffix=OPENCODE_SEED_SUFFIX)
+
+
+async def purge_seed(store, seed_id: str):
+    """Purge an opencode seed (doc + its GridFS blob) in one call.
+
+    Takes an optio store binding (``optio.store``) as-is, per the Shared-
+    contracts surface. Mirrors `optio_claudecode.purge_seed`; both are thin
+    re-exports of the `optio_agents.seeds.purge_seed` engine, which expunges
+    the seed doc and its GridFS blob and raises KeyError if absent.
+    """
+    return await seeds.purge_seed(
+        store.db, prefix=store.prefix, suffix=OPENCODE_SEED_SUFFIX, seed_id=seed_id,
+    )