virtuai-cli 1.0.4__tar.gz → 1.0.6__tar.gz

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 1.0.4
+Version: 1.0.6
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "1.0.4"
+version = "1.0.6"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "1.0.4"
+__version__ = "1.0.6"

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli/main.py

@@ -151,7 +151,7 @@ def unpair():
     cfg.delete_token(cfg._KEYRING_CLI_TOKEN_KEY)
     console.print("[yellow]Unpaired.[/yellow] CLI token cleared.")
     console.print(
-        "[dim]If you ran virtuai opencode, remove provider.virtuai from "
+        "[dim]If you ran virtuai opencode, remove providers.virtuai from "
         "~/.config/opencode/opencode.json — that file still holds a copy of the token.[/dim]"
     )
 
@@ -476,7 +476,7 @@ def opencode(
 ):
     """Point the local OpenCode TUI at this workspace's VirtuAI agents.
 
-    Copies the CLI pairing token into OpenCode as provider.virtuai.options.apiKey
+    Copies the CLI pairing token into OpenCode 2 as providers.virtuai.settings.apiKey
     (OpenCode cannot read the OS keychain). Keeps local-llm, plugins, and mcp.
     """
     from virtuai_cli.opencode import install_opencode

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli/opencode.py

@@ -1,10 +1,11 @@
 """Point the local OpenCode TUI at VirtuAI agents.
 
-OpenCode is a Chat Completions client. ``virtuai opencode`` merges a
-``provider.virtuai`` block into ``~/.config/opencode/opencode.json``. The
-``apiKey`` is the same CLI pairing (or login) token already in the OS keychain
-— OpenCode cannot read the keychain, so the token is copied into that file as
-``Authorization: Bearer``.
+OpenCode is a Chat Completions client. ``virtuai opencode`` writes native
+OpenCode 2 config into ``~/.config/opencode/opencode.json``: ``providers.virtuai``
+and ``agents.*``. A previous ``provider.virtuai`` block this command wrote is
+removed on the next run. The ``apiKey`` is the same CLI pairing (or login)
+token already in the OS keychain — OpenCode cannot read the keychain, so the
+token is copied into that file as ``Authorization: Bearer``.
 """
 
 from __future__ import annotations
@@ -183,27 +184,85 @@ def _opencode_model_entry(m: dict) -> dict:
     entry["limit"] = {
         "context": context,
         "output": output,
-        # OpenCode's usable() only applies compaction.reserved on the
+        # OpenCode's usable() applies the compaction buffer on the
         # limit.input branch; without this key the buffer is dead config.
         "input": int(limit.get("input") or max(0, context - output)),
     }
     return entry
 
 
-def _ensure_host_permissions(block: dict, *, read_only: bool) -> None:
-    perm = block.setdefault("permission", {})
-    if not isinstance(perm, dict):
-        return
-    perm.setdefault("read", "allow")
-    perm.setdefault("grep", "allow")
-    perm.setdefault("glob", "allow")
-    if not read_only:
-        perm.setdefault("bash", "allow")
-        perm.setdefault("edit", "allow")
-        # OpenCode asks for this after three byte-identical consecutive tool
-        # calls. There is no approval path on this transport, so a prompt here
-        # stalls the session.
-        perm.setdefault("doom_loop", "allow")
+# v1 permission names that OpenCode 2 renamed. Anything else is copied as-is.
+_V1_PERMISSION_ACTIONS = {
+    "bash": "shell",
+    "write": "edit",
+    "patch": "edit",
+    "task": "subagent",
+}
+_BUILD_ALLOWS = ("read", "grep", "glob", "edit", "shell", "doom_loop")
+_PLAN_ALLOWS = ("read", "grep", "glob")
+# Values this command used to write. Only these are removed; a user edit stays.
+_LEGACY_PRUNE = True
+_LEGACY_RESERVED = 20_000
+
+
+def _v1_permissions_to_v2(perm: dict) -> list[dict]:
+    rules: list[dict] = []
+    seen: set[str] = set()
+    for action, effect in perm.items():
+        if not isinstance(action, str) or not isinstance(effect, str):
+            continue
+        name = _V1_PERMISSION_ACTIONS.get(action, action)
+        if name in seen:
+            continue
+        seen.add(name)
+        rules.append({"action": name, "resource": "*", "effect": effect})
+    return rules
+
+
+def _fill_allow_rules(block: dict, actions: tuple[str, ...]) -> None:
+    """Add allow-rules that are missing. Leave any rule the user already set."""
+    rules = block.get("permissions")
+    if not isinstance(rules, list):
+        rules = []
+        block["permissions"] = rules
+    present = {
+        rule.get("action")
+        for rule in rules
+        if isinstance(rule, dict) and isinstance(rule.get("action"), str)
+    }
+    for action in actions:
+        if action in present:
+            continue
+        rules.append({"action": action, "resource": "*", "effect": "allow"})
+        present.add(action)
+
+
+def _lift_owned_agent(agents: dict, legacy: dict, name: str) -> dict:
+    """Move a VirtuAI-owned v1 agent under ``agents`` as one v2 object.
+
+    A native block already present wins. Otherwise the v1 block is copied and
+    its renamed fields are translated, then the v1 key is deleted so the agent
+    is not half ``permission`` and half ``permissions``.
+    """
+    current = agents.get(name)
+    if isinstance(current, dict):
+        block = current
+    else:
+        source = legacy.get(name)
+        block = deepcopy(source) if isinstance(source, dict) else {}
+        prompt = block.pop("prompt", None)
+        if prompt is not None and "system" not in block:
+            block["system"] = prompt
+        perm = block.pop("permission", None)
+        if isinstance(perm, dict) and not isinstance(block.get("permissions"), list):
+            block["permissions"] = _v1_permissions_to_v2(perm)
+        if "disable" in block and "disabled" not in block:
+            block["disabled"] = block.pop("disable")
+        else:
+            block.pop("disable", None)
+        agents[name] = block
+    legacy.pop(name, None)
+    return block
 
 
 def _ensure_compaction(cfg_out: dict) -> None:
@@ -215,19 +274,24 @@ def _ensure_compaction(cfg_out: dict) -> None:
     against token counts the agent loop reports. ``SummarizationMiddleware`` in
     the deep agent is what actually compacts.
 
-    ``auto: false`` disables the automatic path on both the v1 and v2 runtimes.
-    ``/compact`` still works as a manual escape hatch. ``prune`` is kept: it
-    only clears stale tool output from OpenCode's own transcript, which is
-    harmless and keeps its context gauge honest.
+    ``auto: false`` disables the automatic path. ``/compact`` still works as a
+    manual escape hatch. OpenCode 2 reads ``buffer`` and warns on ``prune``, so
+    this command no longer writes ``prune`` or ``reserved``.
 
-    Existing user values are left alone.
+    Existing user values are left alone. ``buffer`` is filled from ``reserved``
+    when the user set a reserve and never set a buffer.
     """
     block = cfg_out.setdefault("compaction", {})
     if not isinstance(block, dict):
         return
     block.setdefault("auto", False)
-    block.setdefault("prune", True)
-    block.setdefault("reserved", 20_000)
+    if "buffer" not in block and "reserved" in block:
+        block["buffer"] = block["reserved"]
+    block.setdefault("buffer", _LEGACY_RESERVED)
+    if block.get("prune") is _LEGACY_PRUNE:
+        block.pop("prune", None)
+    if block.get("reserved") == _LEGACY_RESERVED:
+        block.pop("reserved", None)
 
 
 def merge_opencode_config(
@@ -238,18 +302,21 @@ def merge_opencode_config(
     models: list[dict],
     default_id: str,
 ) -> dict:
-    """Merge a VirtuAI Completions provider. Preserves local-llm, plugins, mcp."""
+    """Merge a native OpenCode 2 VirtuAI provider. Preserves local-llm, plugins, mcp."""
     cfg_out = deepcopy(existing) if existing else {}
     cfg_out.setdefault("$schema", "https://opencode.ai/config.json")
     v1 = base_url.rstrip("/")
     if not v1.endswith("/v1"):
         v1 = f"{v1}/v1"
 
-    provider = cfg_out.setdefault("provider", {})
-    provider["virtuai"] = {
-        "npm": "@ai-sdk/openai-compatible",
+    providers = cfg_out.setdefault("providers", {})
+    if not isinstance(providers, dict):
+        providers = {}
+        cfg_out["providers"] = providers
+    providers["virtuai"] = {
+        "package": "aisdk:@ai-sdk/openai-compatible",
         "name": "VirtuAI",
-        "options": {
+        "settings": {
             "baseURL": v1,
             "apiKey": api_key,
             "includeUsage": True,
@@ -258,13 +325,16 @@ def merge_opencode_config(
             m["id"]: _opencode_model_entry(m) for m in models if m.get("id")
         },
     }
+    legacy_provider = cfg_out.get("provider")
+    if isinstance(legacy_provider, dict):
+        legacy_provider.pop("virtuai", None)
+        if not legacy_provider:
+            cfg_out.pop("provider", None)
 
     cfg_out["model"] = f"virtuai/{default_id}"
     # Title generation falls back to the session model when no small model is
     # set, which spends a full agent turn naming a session.
     small_id = pick_small_id(models, default_id)
-    if small_id:
-        cfg_out.setdefault("small_model", f"virtuai/{small_id}")
 
     by_slug: dict[str, str] = {}
     for m in models:
@@ -274,30 +344,68 @@ def merge_opencode_config(
         by_slug[_slug(mid)] = mid
         by_slug[_slug(m.get("name") or "")] = mid
 
+    agents = cfg_out.setdefault("agents", {})
+    if not isinstance(agents, dict):
+        agents = {}
+        cfg_out["agents"] = agents
+    legacy_was_dict = isinstance(cfg_out.get("agent"), dict)
+    legacy = cfg_out["agent"] if legacy_was_dict else {}
+
     build_id = pick_build_id(models)
     plan_id = pick_plan_id(models)
-    agent = cfg_out.setdefault("agent", {})
     if build_id:
-        build = agent.setdefault("build", {})
+        build = _lift_owned_agent(agents, legacy, "build")
         build["model"] = f"virtuai/{build_id}"
-        _ensure_host_permissions(build, read_only=False)
+        _fill_allow_rules(build, _BUILD_ALLOWS)
     if plan_id:
-        plan = agent.setdefault("plan", {})
+        plan = _lift_owned_agent(agents, legacy, "plan")
         plan["model"] = f"virtuai/{plan_id}"
-        _ensure_host_permissions(plan, read_only=True)
-    for key, block in list(agent.items()):
-        if not isinstance(block, dict):
-            continue
-        if key in ("build", "plan"):
+        _fill_allow_rules(plan, _PLAN_ALLOWS)
+
+    owned = {"build", "plan", "compaction", "title"}
+    for key in list(legacy) + list(agents):
+        if key in owned:
             continue
         matched = by_slug.get(_slug(key))
-        if matched:
-            block["model"] = f"virtuai/{matched}"
-
-    if small_id:
-        # Manual /compact otherwise runs a full Build-grade agent turn; OpenCode
-        # honours agent.compaction.model for it.
-        agent.setdefault("compaction", {}).setdefault("model", f"virtuai/{small_id}")
+        if not matched:
+            continue
+        if isinstance(agents.get(key), dict):
+            agents[key]["model"] = f"virtuai/{matched}"
+        elif isinstance(legacy.get(key), dict):
+            legacy[key]["model"] = f"virtuai/{matched}"
+
+    prior_small = cfg_out.get("small_model")
+    title = agents.get("title")
+    if isinstance(title, dict) and title.get("model"):
+        cfg_out.pop("small_model", None)
+    else:
+        chosen = prior_small if isinstance(prior_small, str) and prior_small else None
+        if chosen is None and small_id:
+            chosen = f"virtuai/{small_id}"
+        if chosen:
+            if not isinstance(title, dict):
+                title = {}
+                agents["title"] = title
+            title.setdefault("model", chosen)
+            cfg_out.pop("small_model", None)
+
+    compaction_agent = agents.get("compaction")
+    if not isinstance(compaction_agent, dict):
+        compaction_agent = {}
+    legacy_compaction = legacy.pop("compaction", None)
+    if "model" not in compaction_agent:
+        if isinstance(legacy_compaction, dict) and legacy_compaction.get("model"):
+            compaction_agent["model"] = legacy_compaction["model"]
+        elif small_id:
+            compaction_agent["model"] = f"virtuai/{small_id}"
+    if compaction_agent.get("model"):
+        agents["compaction"] = compaction_agent
+
+    if legacy_was_dict:
+        if legacy:
+            cfg_out["agent"] = legacy
+        else:
+            cfg_out.pop("agent", None)
 
     _ensure_compaction(cfg_out)
     return cfg_out

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli/security.py

@@ -95,11 +95,22 @@ _PASS_THROUGH_ENV = {
     "GOOGLE_CLOUD_PROJECT",
     "GCLOUD_PROJECT",
     "GOOGLE_CLOUD_QUOTA_PROJECT",
+    # Proxy settings. In a VirtuAI sandbox the only way out is its egress
+    # proxy, and without these every pip, curl and requests call the agent
+    # makes fails; on a laptop behind a corporate proxy, the same. They are
+    # set by whoever runs the CLI, never by the server.
+    "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "ALL_PROXY",
+    "http_proxy", "https_proxy", "no_proxy", "all_proxy",
 }
 
 # Env var prefixes whose entire namespace is passed through
 _PASS_THROUGH_PREFIXES = ("VIRTUAI_", "GOOGLE_", "GCLOUD_", "CLOUDSDK_", "AWS_", "AZURE_")
 
+# The runner's own credentials. Under the VIRTUAI_ prefix, they reached every
+# command the agent ran — `env` printed the token, and with it anything the
+# agent read could act as this runner.
+_NEVER_PASSED = {"VIRTUAI_TOKEN", "VIRTUAI_PAIRING_CODE"}
+
 
 def scrub_env(workdir: Path, extra_allow: list[str] | None = None) -> dict[str, str]:
     """Build a clean environment: allowlist + cloud-tool prefixes + user opt-ins.
@@ -116,6 +127,8 @@ def scrub_env(workdir: Path, extra_allow: list[str] | None = None) -> dict[str,
 
     env: dict[str, str] = {}
     for key, value in os.environ.items():
+        if key in _NEVER_PASSED:
+            continue
         if key in allowed or any(key.startswith(p) for p in _PASS_THROUGH_PREFIXES):
             env[key] = value
 

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 1.0.4
+Version: 1.0.6
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-1.0.4 → virtuai_cli-1.0.6}/src/virtuai_cli.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tests/test_ollama_options.py
 tests/test_ollama_state.py
 tests/test_omlx.py
 tests/test_process_group_kill.py
+tests/test_proxy_env.py
 tests/test_pull_fallback.py
 tests/test_run_single_instance.py
 tests/test_session_isolation.py

virtuai_cli-1.0.6/tests/test_proxy_env.py

@@ -0,0 +1,29 @@
+"""The agent's commands keep the proxy settings the runner was started with.
+
+In a VirtuAI sandbox the egress proxy is the only way out; without these,
+every pip, curl and requests call failed.
+"""
+import os
+from pathlib import Path
+
+from virtuai_cli.security import scrub_env
+
+
+def test_proxy_settings_reach_the_agents_commands(monkeypatch, tmp_path: Path):
+    monkeypatch.setenv("HTTPS_PROXY", "http://px-7:3128")
+    monkeypatch.setenv("no_proxy", "localhost")
+    monkeypatch.setenv("SOME_SECRET", "x")
+    env = scrub_env(tmp_path)
+    assert env["HTTPS_PROXY"] == "http://px-7:3128" and env["no_proxy"] == "localhost"
+    assert "SOME_SECRET" not in env
+
+
+def test_the_runners_own_credentials_never_reach_a_command(monkeypatch, tmp_path):
+    from virtuai_cli.security import scrub_env
+
+    monkeypatch.setenv("VIRTUAI_TOKEN", "vai_sbx_secret")
+    monkeypatch.setenv("VIRTUAI_PAIRING_CODE", "ABC-123")
+    monkeypatch.setenv("VIRTUAI_SERVER_URL", "https://dev.imvirtuai.com")
+    env = scrub_env(tmp_path)
+    assert "VIRTUAI_TOKEN" not in env and "VIRTUAI_PAIRING_CODE" not in env
+    assert env["VIRTUAI_SERVER_URL"] == "https://dev.imvirtuai.com"  # the rest of VIRTUAI_* still passes