@maudecode/talaria-web 1.18.0 → 1.20.0

package/sidecar/talaria_sidecar/context_detail.py

@@ -0,0 +1,59 @@
+"""The shared allowlist for native/resident context reads. Never includes prompt bodies or paths."""
+from __future__ import annotations
+
+import math
+import re
+
+CATEGORIES = {'system_prompt', 'tool_definitions', 'rules', 'skills', 'mcp', 'subagent_definitions', 'memory', 'conversation'}
+STATUSES = {'loaded', 'truncated', 'flagged', 'shadowed', 'blocked', 'empty', 'unreadable', 'suppressed'}
+FILE_NAMES = {'AGENTS.md', 'SOUL.md', '.hermes.md', 'CLAUDE.md', 'GEMINI.md', 'CONTEXT.md'}
+
+
+def number(value):
+    return value if type(value) in (int, float) and 0 <= value <= 2**53 - 1 and math.isfinite(value) and int(value) == value else None
+
+
+def unavailable(reason='unavailable') -> dict:
+    return {'available': False, 'reason': reason, 'used_tokens': None, 'window_tokens': None,
+            'source': None, 'estimated': None, 'estimated_total': None, 'categories': [], 'files': [],
+            'truncated': False, 'current_turn_output_tokens': None, 'last_turn_output_tokens': None}
+
+
+def project(payload, *, usage=None, running=False) -> dict:
+    if not isinstance(payload, dict):
+        return unavailable('unsupported')
+    rows = payload.get('categories')
+    if not isinstance(rows, list) or not rows:
+        return unavailable('not_built')
+    maximum = number(payload.get('context_max')) or None
+    categories, seen = [], set()
+    for row in rows[:64]:
+        if not isinstance(row, dict) or not isinstance(row.get('id'), str) or row.get('id') not in CATEGORIES or row['id'] in seen:
+            continue
+        tokens = number(row.get('tokens'))
+        if tokens is None:
+            continue
+        seen.add(row['id'])
+        categories.append({'id': row['id'], 'tokens': int(tokens), 'percent': min(100, tokens / maximum * 100) if maximum else None, 'estimated': True})
+    if not categories:
+        return unavailable('not_built')
+    source = payload.get('context_source')
+    source = source if isinstance(source, str) and source in {'provider_usage', 'local_estimate', 'provider_usage_plus_estimate'} else None
+    files = payload.get('context_files')
+    files = files if isinstance(files, list) else []
+    safe_files = []
+    for row in files[:64]:
+        if not isinstance(row, dict):
+            continue
+        # Labels from owners can include the entire private directory. Keep known context basenames only.
+        name = re.split(r'[/\\]', str(row.get('path') or ''))[-1]
+        label = name if name in FILE_NAMES else row.get('label') if isinstance(row.get('label'), str) and row.get('label') in FILE_NAMES else 'Context file'
+        status = row.get('status') if isinstance(row.get('status'), str) and row.get('status') in STATUSES else 'unknown'
+        safe_files.append({'label': label, 'characters': number(row.get('chars')), 'tokens': number(row.get('est_tokens')),
+                           'status': status, 'loaded': status in {'loaded', 'truncated', 'flagged'} if status != 'unknown' else None})
+    output = number(usage.get('last_turn_tokens')) if isinstance(usage, dict) else None
+    return {'available': True, 'reason': None, 'used_tokens': number(payload.get('context_used')), 'window_tokens': maximum,
+            'source': source, 'estimated': source != 'provider_usage' if source else None,
+            'estimated_total': number(payload.get('estimated_total')), 'categories': categories, 'files': safe_files,
+            'truncated': len(rows) > 64 or len(files) > 64,
+            'current_turn_output_tokens': output if running else None, 'last_turn_output_tokens': output if not running else None}

package/sidecar/talaria_sidecar/dependency_sync.py

@@ -0,0 +1,85 @@
+"""Own an Agent sync process tree until completion or the sidecar's stdin pipe closes.
+
+This small supervisor survives a killed sidecar long enough to stop and reap the
+writer. Its OS lock prevents a replacement sidecar from starting another writer
+before that cleanup finishes. Only stdlib imports, even with broken Agent deps.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import threading
+
+
+def _lock(file) -> None:
+    if os.name == "nt":
+        import msvcrt
+        file.seek(0)
+        if not file.read(1):
+            file.write(b"0")
+            file.flush()
+        file.seek(0)
+        msvcrt.locking(file.fileno(), msvcrt.LK_NBLCK, 1)
+    else:
+        import fcntl
+        fcntl.flock(file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+
+def _stop_tree(child: subprocess.Popen) -> None:
+    if os.name == "nt":
+        # taskkill is part of Windows and terminates the descendants as well.
+        subprocess.run(["taskkill", "/PID", str(child.pid), "/T", "/F"],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+    else:
+        try:
+            os.killpg(child.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+    child.wait()
+
+
+def main() -> int:
+    root = Path(sys.argv[1]).resolve()
+    stopped = threading.Event()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        signal.signal(sig, lambda *_: stopped.set())
+
+    def owner_exited() -> None:
+        try:
+            os.read(0, 1)
+        finally:
+            stopped.set()
+
+    threading.Thread(target=owner_exited, daemon=True).start()
+    lock_path = Path(os.environ["HERMES_HOME"]) / ".talaria-agent-sync" / hashlib.sha256(os.fsencode(root)).hexdigest()
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+b") as lease:
+        try:
+            _lock(lease)
+        except OSError:
+            print("Another Agent dependency sync is still running.", file=sys.stderr)
+            return 1
+        if stopped.is_set():
+            return 1
+        child = subprocess.Popen(
+            [sys.executable, "-m", "hermes_cli.venv_sync", "--project-root", str(root), "--json"],
+            cwd=root, stdin=subprocess.DEVNULL, start_new_session=os.name != "nt",
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0,
+        )
+        try:
+            while child.poll() is None:
+                if stopped.wait(0.05):
+                    _stop_tree(child)
+                    return 1
+            return child.returncode
+        finally:
+            if child.poll() is None:
+                _stop_tree(child)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/sidecar/talaria_sidecar/home.py

@@ -24,6 +24,7 @@ its launch-process ``TERMINAL_*`` under those files.
 from __future__ import annotations
 
 import contextlib
+import copy
 import importlib
 import json
 import logging
@@ -42,7 +43,85 @@ _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()
+_SCOPE_CACHE_LOCK = threading.Lock()
+_SCOPE_CACHE: dict[str, dict] = {}
+_SCOPE_CACHE_MAX = 64
+
+
+def _scope_stamp(home: Path) -> tuple | None:
+    stamps = []
+    for name in (".env", "config.yaml"):
+        try:
+            st = (home / name).stat()
+        except FileNotFoundError:
+            stamps.append(None)
+        except OSError:
+            return None  # Uncertain identity must never reuse credentials or terminal authority.
+        else:
+            stamps.append((st.st_dev, st.st_ino, st.st_mtime_ns, st.st_ctime_ns, st.st_size, st.st_mode))
+    return tuple(stamps)
+
+
+def _cached_scope(home: Path, kind: str, stamp: tuple | None, inputs, build):
+    """One snapshot of each kind per home; bindings receive copies, never the memo itself."""
+    key = str(home.absolute())
+    with _SCOPE_CACHE_LOCK:
+        scopes = _SCOPE_CACHE.pop(key, {})
+        _SCOPE_CACHE[key] = scopes
+        while len(_SCOPE_CACHE) > _SCOPE_CACHE_MAX:
+            del _SCOPE_CACHE[next(iter(_SCOPE_CACHE))]
+        cached = scopes.pop(kind, None)
+        if (
+            stamp is not None
+            and cached is not None
+            and cached[:2] == (stamp, inputs)
+            and _scope_stamp(home) == stamp
+        ):
+            scopes[kind] = cached
+            return copy.deepcopy(cached[2])
+        value = build()
+        # A writer racing the build cannot lend its file identity to stale bytes.
+        if stamp is not None and _scope_stamp(home) == stamp:
+            scopes[kind] = (stamp, copy.deepcopy(inputs), copy.deepcopy(value))
+        return value
+
+
+def _secret_scope_inputs(home: Path, named: bool):
+    """File stamps alone cannot detect vault refreshes, managed policy, or launch-env edits."""
+    try:
+        from hermes_cli.env_loader import get_secret_source_values
+        from hermes_cli.managed_scope import load_managed_env
+        from gateway.config_loader import bridged_allow_all_users
+
+        launch = None
+        if not named:
+            try:
+                from tui_gateway.launch_profile_policy import _launch_env
+            except ImportError:
+                from agent.secret_scope import is_multiplex_active
+
+                launch = _frozen_launch_env() if is_multiplex_active() else dict(os.environ)
+            else:
+                launch = _launch_env()
+        return (get_secret_source_values(home), load_managed_env(), bridged_allow_all_users(), launch)
+    except Exception:  # Older/partial Agents keep the original uncached builder and its policy.
+        return None
+
+
+def _process_home() -> Path:
+    explicit = os.environ.get("HERMES_HOME", "")
+    if explicit:
+        return Path(explicit).expanduser()
+    # Match Agent's literal suffix without importing Agent during sidecar startup.
+    suffix = os.environ.get("HERMES_DATA_DIR_SUFFIX", "")
+    if sys.platform == "win32":
+        local_appdata = os.environ.get("LOCALAPPDATA", "").strip()
+        base = Path(local_appdata) if local_appdata else Path.home() / "AppData" / "Local"
+        return base / ("hermes" + suffix)
+    return Path.home() / (".hermes" + suffix)
+
+
+_PROCESS_HOME = _process_home()
 
 
 def _is_named_profile(home: Path) -> bool:
@@ -103,7 +182,7 @@ def _launch_secret_scope(home: Path) -> dict[str, str]:
 
 
 @contextlib.contextmanager
-def _secret_scope(home: Path):
+def _secret_scope(home: Path, stamp: tuple | None = None, *, load_plugins: bool = True):
     """Install ``home``'s credential scope for the call; named profiles run under multiplex semantics."""
     named = _is_named_profile(home)
     try:
@@ -125,10 +204,18 @@ def _secret_scope(home: Path):
         return
     if named:
         activate_multi_profile_hosting()
-        hydrate_profile_secret_sources(home)
-        secrets = build_profile_secret_scope(home)
-    else:
-        secrets = launch_secret_scope(home)
+        # Dashboard hosting must never load third-party code into this sidecar.
+        if load_plugins:
+            try:
+                from hermes_cli.plugins import discover_plugins
+
+                discover_plugins()
+            except Exception:  # noqa: BLE001 - a broken plugin must not block the call, as in the Agent's own discovery
+                log.debug("Plugin discovery failed for %s", home, exc_info=True)
+            hydrate_profile_secret_sources(home)
+    build = lambda: build_profile_secret_scope(home) if named else launch_secret_scope(home)
+    inputs = _secret_scope_inputs(home, named)
+    secrets = build() if inputs is None else _cached_scope(home, "secrets", stamp, inputs, build)
     scope_token = set_secret_scope(secrets)
     try:
         yield
@@ -137,7 +224,7 @@ def _secret_scope(home: Path):
 
 
 @contextlib.contextmanager
-def _terminal_scope(home: Path):
+def _terminal_scope(home: Path, stamp: tuple | None = None):
     """Install ``home``'s terminal policy for the call; a policy file that cannot be read refuses terminal execution."""
     named = _is_named_profile(home)
     try:
@@ -150,9 +237,8 @@ def _terminal_scope(home: Path):
             )
         yield
         return
-    if named:
-        token = install_profile_terminal_scope(home)
-    else:
+    launch = None
+    if not named:
         try:
             from agent.secret_scope import is_multiplex_active
         except ImportError:  # An Agent without multiplexing cannot layer the launch env, so the launch profile keeps the process env
@@ -164,7 +250,19 @@ def _terminal_scope(home: Path):
             launch_terminal_env = _launch_terminal_env
         # 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:
+        from tools.terminal_scope import build_profile_terminal_scope, set_terminal_scope, TerminalPolicyRefusal, TerminalPolicyUnavailable
+    except ImportError:  # Keep the installed Agent's original behavior when its builder API is absent.
+        token = install_profile_terminal_scope(home, env_overlay=launch) if not named else install_profile_terminal_scope(home)
+    else:
+        try:
+            policy = _cached_scope(
+                home, "terminal", stamp, (launch, str(Path.home())),
+                lambda: build_profile_terminal_scope(home, env_overlay=launch),
+            )
+        except (OSError, TerminalPolicyUnavailable) as exc:
+            policy = TerminalPolicyRefusal(str(exc))
+        token = set_terminal_scope(policy)
     try:
         yield
     finally:
@@ -212,9 +310,10 @@ def _recover_processes(home: Path) -> None:
 
 
 @contextlib.contextmanager
-def scoped_home(home: Path):
+def scoped_home(home: Path, *, load_plugins: bool = True):
     """Run the body with Hermes Agent resolving ``get_hermes_home()`` to ``home``."""
     home = Path(home).expanduser()
+    stamp = _scope_stamp(home)
     try:
         from hermes_constants import reset_hermes_home_override, set_hermes_home_override
     except Exception:  # noqa: BLE001 - older Agent without context-local homes
@@ -222,7 +321,7 @@ def scoped_home(home: Path):
     if set_hermes_home_override is not None:
         token = set_hermes_home_override(home)
         try:
-            with _secret_scope(home), _terminal_scope(home):
+            with _secret_scope(home, stamp, load_plugins=load_plugins), _terminal_scope(home, stamp):
                 _recover_processes(home)
                 yield home
         finally:
@@ -232,7 +331,7 @@ def scoped_home(home: Path):
         previous = os.environ.get("HERMES_HOME")
         os.environ["HERMES_HOME"] = str(home)
         try:
-            with _secret_scope(home), _terminal_scope(home):
+            with _secret_scope(home, stamp, load_plugins=load_plugins), _terminal_scope(home, stamp):
                 _recover_processes(home)
                 yield home
         finally:
@@ -240,3 +339,23 @@ def scoped_home(home: Path):
                 os.environ.pop("HERMES_HOME", None)
             else:
                 os.environ["HERMES_HOME"] = previous
+
+
+@contextlib.contextmanager
+def session_workspace(workspace: str | None):
+    """Bind the session's declared workspace (the Agent's ``_SESSION_CWD``), so terminals, AGENTS.md discovery and goal
+    gates run there instead of the sidecar's launch directory. No workspace keeps the Agent's own resolution. A context
+    variable, so concurrent calls never share it; a missing Agent surface is logged, not fatal."""
+    try:
+        from agent.runtime_cwd import _SESSION_CWD
+    except Exception:  # noqa: BLE001
+        log.debug("session cwd bind unavailable", exc_info=True)
+        _SESSION_CWD = None
+    if not workspace or _SESSION_CWD is None:
+        yield
+        return
+    token = _SESSION_CWD.set(str(workspace))
+    try:
+        yield
+    finally:
+        _SESSION_CWD.reset(token)

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, checkpoints, commands, config, cron, gateway, goals, kanban, mcp, oauth, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
+    from . import aux, chat, checkpoints, commands, config, connectors, cron, dashboard_plugins, gateway, goals, kanban, mcp, memory, oauth, plugin_oauth, process, profiles, providers, skills, state_db, stt, text, toolsets, usage, worktree, write_approval  # noqa: WPS433
     from . import runtime as runtime_methods
 
-    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, aux, text, process, usage, gateway, worktree, checkpoints, chat, config):
+    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, plugin_oauth, aux, text, process, usage, gateway, worktree, checkpoints, memory, chat, config, toolsets, write_approval, connectors, dashboard_plugins):
         module.register(registry)
     return registry.methods