@maudecode/talaria-web 0.0.0

package/sidecar/talaria_sidecar/methods/mcp.py

@@ -0,0 +1,65 @@
+"""``mcp.*``: the Agent's MCP registry (status, known tools, reconnect).
+
+Config edits and health probes live in the server; this namespace only reads
+``tools.mcp_tool`` and ``tools.registry`` state without spawning servers.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+from .commands import _reload_mcp
+
+log = logging.getLogger("talaria_sidecar.mcp")
+
+
+def status() -> list[dict]:
+    try:
+        from tools.mcp_tool import get_mcp_status
+
+        statuses = get_mcp_status()
+    except Exception:  # noqa: BLE001
+        return []
+    return [dict(entry) for entry in statuses if isinstance(entry, dict) and entry.get("name")] if isinstance(statuses, list) else []
+
+
+def registry_tools() -> list[dict]:
+    """Already-registered MCP tool schemas, without probing any server."""
+    try:
+        from tools.registry import registry
+    except Exception:  # noqa: BLE001
+        return []
+    out = []
+    try:
+        names = registry.get_all_tool_names()
+    except Exception:  # noqa: BLE001
+        return []
+    for tool_name in names:
+        try:
+            toolset = registry.get_toolset_for_tool(tool_name)
+        except Exception:  # noqa: BLE001
+            continue
+        if not isinstance(toolset, str) or not toolset.startswith("mcp-"):
+            continue
+        schema = registry.get_schema(tool_name) or {}
+        out.append({"name": tool_name, "server": toolset[len("mcp-"):], "schema": schema if isinstance(schema, dict) else {}})
+    return out
+
+
+def register(registry_) -> None:
+    @registry_.method("mcp.status")
+    def status_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"servers": status()}
+
+    @registry_.method("mcp.registry_tools")
+    def tools(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"tools": registry_tools()}
+
+    @registry_.method("mcp.reload")
+    def reload(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"output": _reload_mcp()}

package/sidecar/talaria_sidecar/methods/process.py

@@ -0,0 +1,155 @@
+"""``process.*``: the Agent's background process registry (completion queue,
+async delegation claims). The server keeps the WebUI session index and decides
+routing; the sidecar drains and formats registry events."""
+
+from __future__ import annotations
+
+import logging
+import queue
+
+from ..errors import InvalidParams
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+log = logging.getLogger("talaria_sidecar.process")
+
+
+def _registry():
+    try:
+        from tools.process_registry import process_registry
+    except Exception:  # noqa: BLE001
+        return None
+    return process_registry
+
+
+def _event_row(evt: dict) -> dict:
+    registry = _registry()
+    row = {str(k): v for k, v in evt.items()} if isinstance(evt, dict) else {}
+    process_id = str(row.get("delegation_id") or row.get("session_id") or row.get("task_id") or "") if row.get("type") == "async_delegation" else str(row.get("session_id") or "")
+    row["process_id"] = process_id
+    if registry is not None and process_id and (not row.get("session_key") or not row.get("origin_ui_session_id")):
+        try:
+            proc = registry.get(process_id)
+        except Exception:  # noqa: BLE001
+            proc = None
+        if proc is not None:
+            row.setdefault("session_key", str(getattr(proc, "session_key", "") or ""))
+            if not row.get("origin_ui_session_id"):
+                row["origin_ui_session_id"] = str(getattr(proc, "origin_ui_session_id", "") or "") or str(getattr(proc, "spawn_session_id", "") or "")
+    try:
+        row["consumed"] = bool(registry is not None and process_id and row.get("type") != "async_delegation" and registry.is_completion_consumed(process_id))
+    except Exception:  # noqa: BLE001
+        row["consumed"] = False
+    return row
+
+
+def drain(max_events: int) -> list[dict]:
+    """Pop every queued completion event; the server requeues what it does not own."""
+    registry = _registry()
+    completion_queue = getattr(registry, "completion_queue", None) if registry is not None else None
+    if completion_queue is None:
+        return []
+    out = []
+    while len(out) < max_events:
+        try:
+            evt = completion_queue.get_nowait()
+        except queue.Empty:
+            break
+        except Exception:  # noqa: BLE001
+            log.debug("Failed to drain process completion queue", exc_info=True)
+            break
+        out.append(_event_row(evt))
+    return out
+
+
+def requeue(events: list[dict]) -> int:
+    registry = _registry()
+    completion_queue = getattr(registry, "completion_queue", None) if registry is not None else None
+    if completion_queue is None:
+        return 0
+    count = 0
+    for evt in events:
+        try:
+            completion_queue.put_nowait({k: v for k, v in evt.items() if k not in ("process_id", "consumed")})
+            count += 1
+        except Exception:  # noqa: BLE001
+            log.debug("Failed to requeue process completion", exc_info=True)
+    return count
+
+
+def mark_consumed(process_id: str) -> bool:
+    registry = _registry()
+    if registry is None:
+        return False
+    try:
+        with registry._lock:
+            registry._completion_consumed.add(process_id)
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def format_notification(evt: dict) -> str:
+    if evt.get("type") == "async_delegation":
+        try:
+            from tools.process_registry import format_process_notification
+
+            return format_process_notification(evt) or ""
+        except Exception:  # noqa: BLE001
+            return ""
+    if evt.get("type") != "completion":
+        return ""
+    output = str(evt.get("output") or "")
+    if len(output) > 4000:
+        output = output[:4000] + "\n... (truncated)"
+    return f"[IMPORTANT: Background process {evt.get('session_id', '')} completed (exit code {evt.get('exit_code', '')}).\nCommand: {evt.get('command', '')}\nOutput:\n{output}]"
+
+
+def list_sessions() -> list[dict]:
+    registry = _registry()
+    if registry is None:
+        return []
+    out = []
+    try:
+        rows = registry.list_sessions()
+    except Exception:  # noqa: BLE001
+        return []
+    for row in rows or []:
+        if isinstance(row, dict):
+            out.append({str(k): v for k, v in row.items()})
+        elif hasattr(row, "__dict__"):
+            out.append({k: v for k, v in vars(row).items() if not k.startswith("_") and isinstance(v, (str, int, float, bool, type(None)))})
+    return out
+
+
+def register(registry_) -> None:
+    @registry_.method("process.drain")
+    def drain_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"events": drain(int(params.get("max_events") or 256))}
+
+    @registry_.method("process.requeue")
+    def requeue_(ctx: CallContext, params: dict) -> dict:
+        events = params.get("events")
+        if not isinstance(events, list):
+            raise InvalidParams("events must be a list")
+        return {"requeued": requeue([e for e in events if isinstance(e, dict)])}
+
+    @registry_.method("process.mark_consumed")
+    def consumed(ctx: CallContext, params: dict) -> dict:
+        process_id = str(params.get("process_id") or "").strip()
+        if not process_id:
+            raise InvalidParams("process_id is required")
+        return {"ok": mark_consumed(process_id)}
+
+    @registry_.method("process.format_notification")
+    def format_(ctx: CallContext, params: dict) -> dict:
+        evt = params.get("event")
+        if not isinstance(evt, dict):
+            raise InvalidParams("event must be an object")
+        return {"text": format_notification(evt)}
+
+    @registry_.method("process.list")
+    def list_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"sessions": list_sessions()}

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -0,0 +1,254 @@
+"""``profiles.*``: Hermes profile inventory and lifecycle (ported from api/profiles.py).
+
+The server owns the active-profile cookie, ``active_profile`` file reads,
+isolated-profile mode, and profile-home resolution. The sidecar owns what
+needs Agent code: the profile rows (model/provider/gateway/skill counts),
+create/seed/delete through ``hermes_cli.profiles``, and the runtime env.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import shutil
+from pathlib import Path
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param
+from ..rpc import CallContext
+
+log = logging.getLogger("talaria_sidecar.profiles")
+_PROFILE_ID_RE = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}")
+_PROFILE_DIRS = ("skills", "memories", "sessions", "logs", "cron")
+_CLONE_CONFIG_FILES = ("config.yaml", ".env", "SOUL.md")
+_TERMINAL_ENV = {
+    "backend": "TERMINAL_ENV", "env_type": "TERMINAL_ENV", "cwd": "TERMINAL_CWD", "timeout": "TERMINAL_TIMEOUT", "lifetime_seconds": "TERMINAL_LIFETIME_SECONDS",
+    "modal_mode": "TERMINAL_MODAL_MODE", "docker_image": "TERMINAL_DOCKER_IMAGE", "docker_forward_env": "TERMINAL_DOCKER_FORWARD_ENV", "docker_env": "TERMINAL_DOCKER_ENV",
+    "docker_mount_cwd_to_workspace": "TERMINAL_DOCKER_MOUNT_CWD_TO_WORKSPACE", "singularity_image": "TERMINAL_SINGULARITY_IMAGE", "modal_image": "TERMINAL_MODAL_IMAGE",
+    "daytona_image": "TERMINAL_DAYTONA_IMAGE", "container_cpu": "TERMINAL_CONTAINER_CPU", "container_memory": "TERMINAL_CONTAINER_MEMORY", "container_disk": "TERMINAL_CONTAINER_DISK",
+    "container_persistent": "TERMINAL_CONTAINER_PERSISTENT", "docker_volumes": "TERMINAL_DOCKER_VOLUMES", "persistent_shell": "TERMINAL_PERSISTENT_SHELL", "ssh_host": "TERMINAL_SSH_HOST",
+    "ssh_user": "TERMINAL_SSH_USER", "ssh_port": "TERMINAL_SSH_PORT", "ssh_key": "TERMINAL_SSH_KEY", "ssh_persistent": "TERMINAL_SSH_PERSISTENT", "local_persistent": "TERMINAL_LOCAL_PERSISTENT",
+}
+
+
+def _yaml_load(path: Path):
+    try:
+        import yaml
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) if path.exists() else None
+    except Exception:  # noqa: BLE001
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def disabled_skill_names(profile_dir: Path) -> set[str]:
+    cfg = _yaml_load(profile_dir / "config.yaml") or {}
+    skills = cfg.get("skills") if isinstance(cfg.get("skills"), dict) else {}
+    platform = (skills.get("platform_disabled") or {}).get("webui") if isinstance(skills.get("platform_disabled"), dict) else None
+    value = platform if platform is not None else skills.get("disabled")
+    try:
+        from agent.skill_utils import parse_config_string_list
+
+        names = parse_config_string_list(value) if isinstance(value, str) else value
+    except Exception:  # noqa: BLE001
+        names = [value] if isinstance(value, str) else value
+    if names is None:
+        return set()
+    if isinstance(names, str):
+        names = [names]
+    return {str(v).strip() for v in names if str(v).strip()}
+
+
+def skills_stats(profile_dir: Path) -> tuple[int, int]:
+    """(enabled, compatible) counts parsed from every SKILL.md under the profile."""
+    skills_dir = profile_dir / "skills"
+    if not skills_dir.is_dir():
+        return (0, 0)
+    disabled = disabled_skill_names(profile_dir)
+    from agent.skill_utils import iter_skill_index_files, parse_frontmatter, skill_matches_platform
+
+    seen: set[str] = set()
+    enabled = compatible = 0
+    for skill_md in iter_skill_index_files(skills_dir, "SKILL.md"):
+        try:
+            frontmatter, _ = parse_frontmatter(skill_md.read_text(encoding="utf-8")[:4000])
+            if not skill_matches_platform(frontmatter):
+                continue
+            name = frontmatter.get("name", skill_md.parent.name)[:64]
+            if name in seen:
+                continue
+            seen.add(name)
+            compatible += 1
+            if name not in disabled:
+                enabled += 1
+        except Exception:  # noqa: BLE001
+            continue
+    return enabled, compatible
+
+
+def _visible(profile_dir: Path) -> bool:
+    data = _yaml_load(profile_dir / "profile.yaml")
+    return not (isinstance(data, dict) and data.get("visible") is False)
+
+
+def _row(home: Path, name: str, is_default: bool) -> dict:
+    from hermes_cli.profiles import _check_gateway_running, _read_config_model
+
+    try:
+        model, provider = _read_config_model(home)
+    except Exception:  # noqa: BLE001
+        model, provider = None, None
+    try:
+        gateway_running = bool(_check_gateway_running(home))
+    except Exception:  # noqa: BLE001
+        gateway_running = False
+    enabled, total = skills_stats(home)
+    return {
+        "name": name, "path": str(home), "is_default": is_default, "gateway_running": gateway_running, "model": model, "provider": provider,
+        "has_env": (home / ".env").exists(), "visible": _visible(home), "skill_count": enabled, "enabled_skills": enabled, "total_skills": total,
+    }
+
+
+def list_profiles(base_home: Path) -> list[dict]:
+    """Profile rows for the base Hermes home: the root profile plus ``profiles/*``."""
+    from hermes_cli.profiles import _PROFILE_ID_RE as UPSTREAM_ID_RE
+
+    rows = []
+    if base_home.is_dir():
+        rows.append(_row(base_home, "default", True))
+    profiles_root = base_home / "profiles"
+    if profiles_root.is_dir():
+        for entry in sorted(profiles_root.iterdir()):
+            if entry.is_dir() and UPSTREAM_ID_RE.match(entry.name):
+                rows.append(_row(entry, entry.name, False))
+    return rows
+
+
+def validate_name(name: str) -> None:
+    if name == "default":
+        raise InvalidParams("Cannot create a profile named 'default' -- it is the built-in profile.")
+    if not _PROFILE_ID_RE.fullmatch(name or ""):
+        raise InvalidParams(f"Invalid profile name {name!r}. Must match [a-z0-9][a-z0-9_-]{{0,63}}")
+
+
+def create_profile(base_home: Path, name: str, *, clone_from: str | None, clone_config: bool) -> Path:
+    validate_name(name)
+    if clone_from is not None and clone_from != "default":
+        validate_name(clone_from)
+    from .. import home as _home
+
+    with _home.scoped_home(base_home):
+        try:
+            from hermes_cli.profiles import create_profile as upstream_create
+
+            upstream_create(name, clone_from=clone_from, clone_config=clone_config, clone_all=False, no_alias=True)
+        except ImportError:
+            profile_dir = base_home / "profiles" / name
+            if profile_dir.exists():
+                raise RpcError(f"Profile '{name}' already exists.", condition="conflict")
+            profile_dir.mkdir(parents=True, exist_ok=False)
+            for sub in _PROFILE_DIRS:
+                (profile_dir / sub).mkdir(parents=True, exist_ok=True)
+            if clone_config and clone_from:
+                source = base_home if clone_from == "default" else base_home / "profiles" / clone_from
+                if source.is_dir():
+                    for filename in _CLONE_CONFIG_FILES:
+                        if (source / filename).exists():
+                            shutil.copy2(source / filename, profile_dir / filename)
+        except FileExistsError as exc:
+            raise RpcError(str(exc), condition="conflict") from exc
+        except ValueError as exc:
+            raise InvalidParams(str(exc)) from exc
+        profile_dir = base_home / "profiles" / name
+        profile_dir.mkdir(parents=True, exist_ok=True)
+        if clone_from is None:
+            try:
+                from hermes_cli.profiles import seed_profile_skills
+
+                seed_profile_skills(profile_dir, quiet=True)
+            except ImportError:
+                log.debug("seed_profile_skills unavailable")
+            except Exception:  # noqa: BLE001
+                log.warning("Bundled skills could not be seeded for profile %s", name, exc_info=True)
+    return profile_dir
+
+
+def delete_profile(base_home: Path, name: str) -> None:
+    if name == "default":
+        raise InvalidParams("Cannot delete the default profile.")
+    validate_name(name)
+    from .. import home as _home
+
+    with _home.scoped_home(base_home):
+        try:
+            from hermes_cli.profiles import delete_profile as upstream_delete
+
+            upstream_delete(name, yes=True)
+        except ImportError:
+            profile_dir = (base_home / "profiles" / name).resolve()
+            profile_dir.relative_to((base_home / "profiles").resolve())
+            if not profile_dir.is_dir():
+                raise RpcError(f"Profile '{name}' does not exist.", condition="not_found")
+            shutil.rmtree(str(profile_dir))
+        except FileNotFoundError as exc:
+            raise RpcError(str(exc), condition="not_found") from exc
+        except ValueError as exc:
+            raise InvalidParams(str(exc)) from exc
+
+
+def runtime_env(home: Path, protected_keys: set[str]) -> dict[str, str]:
+    """Env vars an agent turn for this profile home needs (terminal config + .env)."""
+    env: dict[str, str] = {}
+    cfg = _yaml_load(home / "config.yaml") or {}
+    terminal = cfg.get("terminal") if isinstance(cfg.get("terminal"), dict) else {}
+    for key, env_key in _TERMINAL_ENV.items():
+        if key in terminal and terminal[key] is not None:
+            value = terminal[key]
+            env[env_key] = ("true" if value else "false") if isinstance(value, bool) else json.dumps(value) if isinstance(value, (list, dict)) else str(value)
+    env_path = home / ".env"
+    if env_path.exists():
+        try:
+            for line in env_path.read_text(encoding="utf-8").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    k, v = line.split("=", 1)
+                    k, v = k.strip(), v.strip().strip('"').strip("'")
+                    if k and v and k not in protected_keys:
+                        env[k] = v
+        except Exception:  # noqa: BLE001
+            log.debug("Failed to read runtime env from %s", env_path)
+    return env
+
+
+def register(registry) -> None:
+    @registry.method("profiles.list")
+    def list_(ctx: CallContext, params: dict) -> dict:
+        return {"profiles": list_profiles(profile_home_param(params, "base_home"))}
+
+    @registry.method("profiles.create")
+    def create(ctx: CallContext, params: dict) -> dict:
+        base = profile_home_param(params, "base_home")
+        name = str(params.get("name") or "").strip()
+        path = create_profile(base, name, clone_from=params.get("clone_from"), clone_config=bool(params.get("clone_config", False)))
+        rows = list_profiles(base)
+        row = next((r for r in rows if r["name"] == name), None) or _row(path, name, False)
+        return {"profile": row}
+
+    @registry.method("profiles.delete")
+    def delete(ctx: CallContext, params: dict) -> dict:
+        delete_profile(profile_home_param(params, "base_home"), str(params.get("name") or "").strip())
+        return {"ok": True}
+
+    @registry.method("profiles.runtime_env")
+    def env(ctx: CallContext, params: dict) -> dict:
+        protected = {str(k) for k in (params.get("protected_keys") or [])}
+        return {"env": runtime_env(profile_home_param(params), protected)}
+
+    @registry.method("profiles.skills_stats")
+    def stats(ctx: CallContext, params: dict) -> dict:
+        enabled, total = skills_stats(profile_home_param(params))
+        return {"enabled": enabled, "total": total}