optio-opencode 0.1.5__tar.gz → 0.1.7__tar.gz

{optio_opencode-0.1.5 → optio_opencode-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.1.5
+Version: 0.1.7
 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.5 → optio_opencode-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "optio-opencode"
-version = "0.1.5"
+version = "0.1.7"
 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.5 → optio_opencode-0.1.7}/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.5 → optio_opencode-0.1.7}/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(
@@ -381,7 +417,10 @@ async def launch_opencode(
     # 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 = {
+        **_isolation_env(host),
         "OPENCODE_DB": f"{host.taskdir}/opencode.db",
         **(extra_env or {}),
     }

optio_opencode-0.1.7/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.mongo_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.mongo_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.mongo_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,
+    )

{optio_opencode-0.1.5 → optio_opencode-0.1.7}/src/optio_opencode/session.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import inspect
 import json
 import logging
 import os
@@ -33,8 +34,10 @@ from optio_agents import HookContext
 from optio_host.host import Host, LocalHost, ProcessHandle, RemoteHost
 from optio_host.paths import task_dir
 from optio_agents.protocol.session import _SessionFailed, run_log_protocol_session
+from optio_agents import seeds as _seeds
 from optio_opencode import host_actions
 from optio_opencode.prompt import compose_agents_md
+from optio_opencode.seed_manifest import OPENCODE_SEED_MANIFEST, OPENCODE_SEED_SUFFIX
 from optio_agents import get_protocol
 from optio_opencode.snapshots import (
     insert_snapshot,
@@ -49,6 +52,10 @@ _LOG = logging.getLogger(__name__)
 
 READY_TIMEOUT_S = 30.0
 
+# Fresh-launch kickoff prompt POSTed to the pre-created opencode session so the
+# agent starts the task unattended. Suppressed on resume.
+AUTO_START_PROMPT = "Read AGENTS.md and execute the task it describes"
+
 
 def _build_host(config: OpencodeTaskConfig, process_id: str) -> Host:
     """Construct the appropriate Host object for the given config.
@@ -84,6 +91,9 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
     opencode_exec: str = "opencode"
     session_id: str | None = None
     preserved_session_id: str | None = None
+    # Worker-side opencode port; hoisted so the finally can query the live
+    # server (for the seed model default) before terminating it.
+    worker_port: int | None = None
 
     # --- resume decision (BEFORE the protocol session starts) -------------
     resume_requested = bool(getattr(ctx, "resume", False))
@@ -161,6 +171,7 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
         terminate the subprocess and capture the snapshot.
         """
         nonlocal launched_handle, opencode_exec, session_id, preserved_session_id
+        nonlocal worker_port
 
         refreshed_files: list[str] = []
         if not resuming:
@@ -182,6 +193,18 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
             await host.write_text(
                 "opencode.json", json.dumps(config.opencode_config, indent=2),
             )
+            if config.seed_id is not None:
+                # Seeded fresh: overlay the stored environment into
+                # <workdir>/home, where the launch's XDG_DATA_HOME /
+                # XDG_CONFIG_HOME point, so the seeded auth.json / opencode.json
+                # are used. Begins a NEW session — no resume.
+                await _seeds.merge_seed(
+                    ctx, host,
+                    seed_id=config.seed_id,
+                    manifest=OPENCODE_SEED_MANIFEST,
+                    suffix=OPENCODE_SEED_SUFFIX,
+                    decrypt=config.session_blob_decrypt,
+                )
             # Note: do NOT call ctx.clear_has_saved_state() here. The spec
             # described it as "belt-and-braces", but in practice it makes
             # `hasSavedState` track the live session rather than the durable
@@ -282,10 +305,28 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
             "iframeSrc": f"{{widgetProxyUrl}}{_workdir_b64}/session/{session_id}",
             "localStorageOverrides": {
                 "opencode.settings.dat:defaultServerUrl": "{widgetProxyUrl}",
+                # Start with the review/diff panel collapsed. opencode defaults
+                # it OPEN (layout store `review.panelOpened ?? true`), eating
+                # the right half of the iframe with a panel that is useless in
+                # this embedded context. The persist layer deep-merges this
+                # partial blob into the layout defaults, so only panelOpened is
+                # forced false; the operator can still toggle it open per
+                # session. (UI-state key — if opencode renames the `layout`
+                # store it silently reverts to default-open.)
+                "opencode.global.dat:layout": '{"review": {"panelOpened": false}}',
             },
         })
         ctx.report_progress(None, "opencode is live")
 
+        # auto_start: on a fresh launch, POST the kickoff prompt to the
+        # pre-created session so opencode starts the task unattended.
+        # Suppressed on resume (the restored session already carries its
+        # conversation; re-prompting would re-trigger the task).
+        if config.auto_start and not resuming:
+            await _post_opencode_prompt(
+                worker_port, password, session_id, AUTO_START_PROMPT,
+            )
+
         # --- await opencode subprocess exit -----------------------------
         # The protocol driver runs this body alongside the tail dispatcher
         # and a cancel watcher.  When the user cancels, the driver cancels
@@ -329,12 +370,51 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
         if not ctx.should_continue():
             cancelled = True
 
+        # Resolve the operator's last-used model BEFORE terminating opencode
+        # (the query needs the live server). Synthesised into the seed's
+        # opencode.json below so an unattended seeded session runs that model
+        # rather than opencode's first-provider fallback. Best-effort.
+        seed_model: str | None = None
+        if (
+            not resuming
+            and config.on_seed_saved is not None
+            and worker_port is not None
+            and session_id is not None
+        ):
+            try:
+                seed_model = await _resolve_session_model(
+                    worker_port, password, session_id,
+                )
+            except Exception:  # noqa: BLE001
+                _LOG.exception(
+                    "seed model resolution failed; seed will carry no model default",
+                )
+
         if launched_handle is not None:
             try:
                 await host.terminate_subprocess(launched_handle, aggressive=cancelled)
             except Exception:  # noqa: BLE001
                 _LOG.exception("terminate_subprocess failed")
 
+        if not resuming and config.on_seed_saved is not None:
+            try:
+                if seed_model is not None:
+                    # Write the model default into the seed's opencode.json
+                    # before capture so it travels in the seed.
+                    await _write_seed_model_config(host, seed_model)
+                seed_id_out = await _seeds.capture_seed(
+                    ctx, host,
+                    manifest=OPENCODE_SEED_MANIFEST,
+                    suffix=OPENCODE_SEED_SUFFIX,
+                    encrypt=config.session_blob_encrypt,
+                )
+                # 2nd arg: the resolved "providerID/modelID" (or None).
+                await _call_maybe_async(
+                    config.on_seed_saved, seed_id_out, seed_model,
+                )
+            except Exception:  # noqa: BLE001
+                _LOG.exception("opencode seed capture failed; callback not fired")
+
         if config.supports_resume and session_id is not None:
             try:
                 await _capture_snapshot(
@@ -384,6 +464,13 @@ async def _read_blob_bytes(ctx: ProcessContext, blob_id) -> bytes:
     return bytes(out)
 
 
+async def _call_maybe_async(fn, *args) -> None:
+    """Invoke a callback that may be sync or async."""
+    result = fn(*args)
+    if inspect.isawaitable(result):
+        await result
+
+
 async def _capture_snapshot(
     ctx: ProcessContext,
     host: Host,
@@ -611,13 +698,172 @@ async def _create_opencode_session(port: int, password: str, directory: str) ->
     )
 
 
+def _post_opencode_prompt_sync(
+    port: int, password: str, session_id: str, message: str,
+) -> None:
+    """Blocking HTTP POST of a kickoff prompt to opencode's session route.
+
+    Called via an executor from :func:`_post_opencode_prompt`. Mirrors
+    :func:`_create_opencode_session_sync`'s BasicAuth + transient-retry pattern
+    (the first request over a freshly-opened SSH local forward occasionally
+    drops while asyncssh wires up the channel).
+
+    Targets opencode's v1 fire-and-forget route ``POST
+    /session/:sessionID/prompt_async`` (same ``/session`` prefix as
+    :func:`_create_opencode_session_sync`). Its ``PromptPayload`` body
+    requires ``parts`` — so ``{"parts": [{"type": "text", "text": msg}]}``.
+    ``prompt_async`` "starts the session if needed and returns immediately"
+    (204 No Content), which is the unattended auto-start semantics we want;
+    the sync ``/session/:id/message`` route blocks streaming the whole AI
+    response. Instance routing comes from opencode's ``process.cwd()`` (the
+    workdir), so no ``?directory=`` query is needed.
+
+    (Earlier targets were both wrong against opencode 1.14.x and crashed the
+    task: the experimental v2 route ``/api/session/:id/prompt`` 400s every
+    body with ``Expected Session.Message`` — the retries exhaust, a
+    RuntimeError aborts the session, opencode is torn down, and the web UI
+    502s its own backend.)
+    """
+    import base64 as _b64
+    import time
+    import urllib.request
+    from urllib.error import URLError
+
+    auth_token = _b64.b64encode(f"opencode:{password}".encode("utf-8")).decode("ascii")
+    url = f"http://127.0.0.1:{port}/session/{session_id}/prompt_async"
+    headers = {
+        "content-type": "application/json",
+        "authorization": f"Basic {auth_token}",
+    }
+    payload = json.dumps(
+        {"parts": [{"type": "text", "text": message}]}
+    ).encode("utf-8")
+
+    last_exc: Exception | None = None
+    for attempt in range(4):
+        if attempt > 0:
+            time.sleep(0.15 * attempt)
+        req = urllib.request.Request(url, method="POST", data=payload, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                resp.read()
+            return
+        except (URLError, ConnectionError, OSError) as exc:
+            last_exc = exc
+            continue
+    raise RuntimeError(
+        f"opencode session prompt failed after retries: {last_exc!r}"
+    )
+
+
+async def _post_opencode_prompt(
+    port: int, password: str, session_id: str, message: str,
+) -> None:
+    loop = asyncio.get_event_loop()
+    await loop.run_in_executor(
+        None, _post_opencode_prompt_sync, port, password, session_id, message
+    )
+
+
+def _resolve_session_model_sync(
+    port: int, password: str, session_id: str,
+) -> str | None:
+    """Best-effort: return the operator's last-used model as
+    ``"providerID/modelID"``, or None.
+
+    GETs opencode's ``/session/:sessionID/message`` (the same ``/session``
+    prefix as :func:`_create_opencode_session_sync`) and walks the message
+    list; each ``info.role == "assistant"`` message carries ``providerID`` /
+    ``modelID``. The LAST such message wins — the operator may switch models
+    mid-session, and their final choice is the one to seed.
+
+    Used at seed-capture time (opencode must still be alive) to synthesise the
+    model default into the seed's ``opencode.json``. Returns None on any
+    transport/parse error or when no assistant message exists; the caller then
+    skips writing a default, leaving opencode's own resolution in place (no
+    worse than before)."""
+    import base64 as _b64
+    import urllib.request
+    from urllib.error import URLError
+
+    auth_token = _b64.b64encode(f"opencode:{password}".encode("utf-8")).decode("ascii")
+    url = f"http://127.0.0.1:{port}/session/{session_id}/message"
+    req = urllib.request.Request(
+        url, method="GET", headers={"authorization": f"Basic {auth_token}"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except (URLError, ConnectionError, OSError, ValueError):
+        return None
+    if not isinstance(data, list):
+        return None
+
+    model: str | None = None
+    for item in data:
+        info = item.get("info", item) if isinstance(item, dict) else {}
+        if not isinstance(info, dict) or info.get("role") != "assistant":
+            continue
+        prov, mod = info.get("providerID"), info.get("modelID")
+        if isinstance(prov, str) and prov and isinstance(mod, str) and mod:
+            model = f"{prov}/{mod}"
+    return model
+
+
+async def _resolve_session_model(
+    port: int, password: str, session_id: str,
+) -> str | None:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        None, _resolve_session_model_sync, port, password, session_id
+    )
+
+
+async def _write_seed_model_config(host: Host, model_str: str) -> None:
+    """Merge ``{"model": model_str}`` into the seed's XDG opencode config at
+    ``<workdir>/home/.config/opencode/opencode.json`` (creating it if absent,
+    preserving any existing keys).
+
+    ``<workdir>/home`` is the seed manifest's ``home_subdir``, and
+    ``.config/opencode/opencode.json`` is in the manifest's include list, so
+    the file travels in the captured seed. On consume, opencode's
+    ``defaultModel()`` reads ``cfg.model`` first — so an unattended seeded
+    session (auto-start ``prompt_async`` sends no model) runs the operator's
+    model instead of the first-provider fallback (anthropic with no key →
+    ``invalid x-api-key``)."""
+    cfg_dir = f"{host.workdir}/home/.config/opencode"
+    cfg_path = f"{cfg_dir}/opencode.json"
+    await host.run_command(f"mkdir -p {shlex.quote(cfg_dir)}")
+
+    existing: dict = {}
+    r = await host.run_command(f"cat {shlex.quote(cfg_path)}")
+    if r.exit_code == 0 and r.stdout.strip():
+        try:
+            parsed = json.loads(r.stdout)
+            if isinstance(parsed, dict):
+                existing = parsed
+        except ValueError:
+            existing = {}
+    existing["model"] = model_str
+    await host.write_text(
+        "home/.config/opencode/opencode.json", json.dumps(existing, indent=2),
+    )
+
+
 def create_opencode_task(
     process_id: str,
     name: str,
     config: OpencodeTaskConfig,
     description: str | None = None,
+    metadata: dict | None = None,
 ) -> TaskInstance:
-    """Return a TaskInstance that runs one opencode web session."""
+    """Return a TaskInstance that runs one opencode web session.
+
+    ``metadata`` is the caller app's task-tagging payload (for later
+    filter/select/identify); it is stamped onto the TaskInstance verbatim and
+    never read by the task itself. Construction is the caller's concern — this
+    factory only accepts and forwards it.
+    """
 
     async def _execute(ctx: ProcessContext) -> None:
         await run_opencode_session(ctx, config)
@@ -629,4 +875,5 @@ def create_opencode_task(
         description=description,
         ui_widget="iframe",
         supports_resume=config.supports_resume,
+        metadata=metadata or {},
     )

{optio_opencode-0.1.5 → optio_opencode-0.1.7}/src/optio_opencode/types.py

@@ -7,7 +7,7 @@ is owned by ``optio-host``. This module re-exports them so existing
 """
 
 from dataclasses import dataclass, field
-from typing import Any, Callable
+from typing import Any, Awaitable, Callable
 
 from optio_agents.protocol.session import DeliverableCallback, HookCallback
 from optio_host.types import SSHConfig
@@ -24,12 +24,14 @@ class OpencodeTaskConfig:
     ssh: SSHConfig | None = None
     on_deliverable: DeliverableCallback | None = None
     install_if_missing: bool = True
-    # Absolute path on the host where the opencode binary is/should be
-    # installed. ``None`` (default) → ``~/.local/bin`` (user home resolved
-    # at task start). The same directory is used for installation, for
-    # smart-install's PATH lookup, and for the post-"ok" ``command -v``
-    # resolution, so an explicit override stays consistent across all
-    # three. Must be an absolute path when set.
+    # Override for the optio-owned opencode binary **cache** directory (where
+    # the opencode binary is installed/cached on the worker). ``None``
+    # (default) → the worker's ``OPENCODE_CACHE_DIR`` or
+    # ``${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin``. Never the host
+    # user's ``~/.local/bin``. The same directory is used for installation,
+    # for smart-install's ``--check`` lookup, and for the post-"ok"
+    # ``command -v`` resolution, so an explicit override stays consistent
+    # across all three. Must be an absolute path when set.
     opencode_install_dir: str | None = None
     workdir_exclude: list[str] | None = None
     supports_resume: bool = True
@@ -51,6 +53,18 @@ class OpencodeTaskConfig:
     # → no refresh; the resumed session keeps its original AGENTS.md.
     on_resume_refresh: Callable[["OpencodeTaskConfig"], "OpencodeTaskConfig"] | None = None
 
+    # --- seed surface (mirrors optio-claudecode) ---
+    seed_id: str | None = None
+    # Fired on teardown of a fresh session after a successful capture, with
+    # two args: (seed_id, info). ``info`` is a human-readable summary of the
+    # captured configuration — for opencode the resolved "providerID/modelID"
+    # (or None if no model was used), mirroring claudecode's account summary.
+    on_seed_saved: "Callable[[str, str | None], Awaitable[None] | None] | None" = None
+    # Fresh launch kicks the agent off unattended via the opencode session API
+    # (POST /api/session/<id>/prompt "Read AGENTS.md and execute the task it
+    # describes"); suppressed on resume.
+    auto_start: bool = False
+
     def __post_init__(self) -> None:
         e = self.session_blob_encrypt is not None
         d = self.session_blob_decrypt is not None

{optio_opencode-0.1.5 → optio_opencode-0.1.7}/src/optio_opencode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.1.5
+Version: 0.1.7
 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