@maudecode/talaria-web 1.15.0 → 1.17.2

package/sidecar/talaria_sidecar/home.py

@@ -14,18 +14,32 @@ fall through to another profile's process environment. Agent 0.21.3 has the
 multiplex switch and secret scopes but not the launch-profile policy module, so
 the sidecar mirrors that policy for it. If the installed Agent has no secret
 scope, named-profile calls fail closed instead.
+
+Terminal policy follows the same split. Under a home override the Agent skips its
+config-to-env terminal bridge, so every call also binds the profile's complete
+``TERMINAL_*`` scope from its own ``.env`` and ``config.yaml``; the launch profile layers
+its launch-process ``TERMINAL_*`` under those files.
 """
 
 from __future__ import annotations
 
 import contextlib
+import importlib
+import json
+import logging
 import os
+import sys
 import threading
 from pathlib import Path
 
 from .errors import InvalidParams, RpcError
 
+log = logging.getLogger("talaria_sidecar.home")
+
 _ENV_LOCK = threading.RLock()
+_RECOVERY_LOCK = threading.Lock()
+_RECOVERED_HOMES: set[str] = set()
+_RECOVERY_WARNED: set[str] = set()
 _LAUNCH_ENV_LOCK = threading.Lock()
 _LAUNCH_ENV: dict[str, str] | None = None
 _PROCESS_HOME = Path(os.environ.get("HERMES_HOME") or Path.home() / ".hermes").expanduser()
@@ -47,6 +61,24 @@ def _frozen_launch_env() -> dict[str, str]:
         return dict(_LAUNCH_ENV)
 
 
+def edit_launch_env(to_set: dict[str, str], to_unset: list[str]) -> None:
+    """Carry a Web-owned ``.env`` edit into the frozen launch environments, so a removed credential stops resolving for the launch profile."""
+
+    def edit(snapshot: dict[str, str] | None) -> None:
+        if snapshot is not None:
+            for name in to_unset:
+                snapshot.pop(name, None)
+            snapshot.update(to_set)
+
+    with _LAUNCH_ENV_LOCK:
+        edit(_LAUNCH_ENV)
+    # Only an imported policy module can hold a frozen snapshot; importing it waits out a first import still running elsewhere.
+    if sys.modules.get("tui_gateway.launch_profile_policy") is not None:
+        policy = importlib.import_module("tui_gateway.launch_profile_policy")
+        with policy._lock:
+            edit(policy._snapshot)
+
+
 def _activate_multi_profile_hosting() -> None:
     """Agent 0.21.3 twin of ``tui_gateway.launch_profile_policy.activate_multi_profile_hosting``."""
     from agent.secret_scope import set_multiplex_active
@@ -99,6 +131,38 @@ def _secret_scope(home: Path):
         reset_secret_scope(scope_token)
 
 
+@contextlib.contextmanager
+def _terminal_scope(home: Path):
+    """Install ``home``'s terminal policy for the call; a policy file that cannot be read refuses terminal execution."""
+    named = _is_named_profile(home)
+    try:
+        from tools.terminal_scope import install_profile_terminal_scope, reset_terminal_scope
+    except Exception:  # noqa: BLE001 - older Agent without terminal scopes
+        if named:
+            raise RpcError(
+                "profile terminal isolation is unavailable in this Hermes Agent; named-profile calls are refused",
+                condition="agent_incompatible",
+            )
+        yield
+        return
+    if named:
+        token = install_profile_terminal_scope(home)
+    else:
+        try:
+            from agent.secret_scope import is_multiplex_active
+            from tui_gateway.launch_profile_policy import launch_terminal_env
+        except ImportError:  # Agent 0.21.3 cannot layer the launch env, so the launch profile keeps the process env
+            yield
+            return
+        # Like the launch secret scope: the live process env until multiplexing freezes it.
+        launch = launch_terminal_env() if is_multiplex_active() else {k: v for k, v in os.environ.items() if k.startswith("TERMINAL_")}
+        token = install_profile_terminal_scope(home, env_overlay=launch)
+    try:
+        yield
+    finally:
+        reset_terminal_scope(token)
+
+
 def profile_home_param(params: dict, key: str = "profile_home") -> Path:
     raw = params.get(key)
     if not isinstance(raw, str) or not raw.strip():
@@ -106,6 +170,36 @@ def profile_home_param(params: dict, key: str = "profile_home") -> Path:
     return Path(raw).expanduser()
 
 
+def _recover_processes(home: Path) -> None:
+    """Re-adopt the live processes a previous run checkpointed in ``home`` (TAL-533), once per home and before the
+    first call in it can spawn: a spawn rewrites ``processes.json`` from the registry and would orphan them. A failed
+    recovery fails the call (and every later one in that home until a retry succeeds), so nothing can overwrite the
+    checkpoint it could not read."""
+    key = str(home.resolve())
+    with _RECOVERY_LOCK:
+        if key in _RECOVERED_HOMES:
+            return
+        try:
+            from tools import process_registry as registry_module
+        except ImportError:  # an Agent without the registry has nothing to recover
+            _RECOVERED_HOMES.add(key)
+            return
+        try:
+            # The Agent reads an unreadable or malformed checkpoint as "nothing to recover"; that must not count as recovered.
+            checkpoint = registry_module._checkpoint_path()
+            if checkpoint.exists() and not isinstance(json.loads(checkpoint.read_text(encoding="utf-8")), list):
+                raise ValueError(f"{checkpoint} is not a list")
+            recovered = registry_module.process_registry.recover_from_checkpoint()
+        except Exception as exc:  # noqa: BLE001
+            # Retried on every call in the home; reported once per home so a lasting failure does not flood the log.
+            log.log(logging.DEBUG if key in _RECOVERY_WARNED else logging.WARNING, "Background process recovery failed for %s", home, exc_info=True)
+            _RECOVERY_WARNED.add(key)
+            raise RpcError(f"background process recovery failed for {home}; its processes.json could not be re-adopted: {exc}") from exc
+        _RECOVERED_HOMES.add(key)
+    if recovered:
+        log.info("Recovered %d background process(es) for %s", recovered, home)
+
+
 @contextlib.contextmanager
 def scoped_home(home: Path):
     """Run the body with Hermes Agent resolving ``get_hermes_home()`` to ``home``."""
@@ -117,7 +211,8 @@ def scoped_home(home: Path):
     if set_hermes_home_override is not None:
         token = set_hermes_home_override(home)
         try:
-            with _secret_scope(home):
+            with _secret_scope(home), _terminal_scope(home):
+                _recover_processes(home)
                 yield home
         finally:
             reset_hermes_home_override(token)
@@ -126,7 +221,8 @@ def scoped_home(home: Path):
         previous = os.environ.get("HERMES_HOME")
         os.environ["HERMES_HOME"] = str(home)
         try:
-            with _secret_scope(home):
+            with _secret_scope(home), _terminal_scope(home):
+                _recover_processes(home)
                 yield home
         finally:
             if previous is None:

package/sidecar/talaria_sidecar/methods/__init__.py

@@ -29,9 +29,9 @@ class Registry:
 
 def build_methods(runtime: AgentRuntime) -> dict[str, Handler]:
     registry = Registry(runtime)
-    from . import aux, chat, commands, config, cron, gateway, goals, kanban, mcp, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
+    from . import aux, chat, commands, config, cron, gateway, goals, kanban, mcp, oauth, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
     from . import runtime as runtime_methods
 
-    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, aux, text, process, usage, gateway, worktree, chat, config):
+    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, aux, text, process, usage, gateway, worktree, chat, config):
         module.register(registry)
     return registry.methods

package/sidecar/talaria_sidecar/methods/aux.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import logging
 import threading
 import uuid
@@ -39,8 +40,10 @@ def resolve_main_runtime(hint: dict | None) -> dict | None:
 
 
 def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
-    """Predecessor fallback: run the main model through ``AIAgent`` with no tools when no auxiliary client answers."""
-    from .chat import _agent_class
+    """Predecessor fallback: run the main model through ``AIAgent`` with no tools when no auxiliary client answers.
+
+    The throwaway agent never touches long-term memory (the prompt is a raw git diff) and is always closed."""
+    from .chat import _agent_class, _supported
 
     AIAgent = _agent_class()
 
@@ -51,8 +54,21 @@ def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
     for name in ("api_mode", "acp_command", "acp_args", "credential_pool"):
         if runtime.get(name) is not None:
             kwargs[name] = runtime[name]
+    for name in ("skip_memory", "skip_background_review"):
+        if _supported(AIAgent, name):
+            kwargs[name] = True
     agent = AIAgent(**kwargs)
-    result = agent.run_conversation(user_message=user, system_message=system, conversation_history=[], task_id=kwargs["session_id"])
+    try:
+        result = agent.run_conversation(user_message=user, system_message=system, conversation_history=[], task_id=kwargs["session_id"])
+    finally:
+        with contextlib.suppress(Exception):
+            agent._end_session_on_close = False
+        close = getattr(agent, "close", None)
+        if callable(close):
+            try:
+                close()
+            except Exception:  # noqa: BLE001
+                log.debug("%s fallback agent close failed", task, exc_info=True)
     return {"model": str(runtime.get("model") or ""), "text": str((result or {}).get("final_response") or "").strip(), "usage": None}