veeam-aiops 0.1.0__tar.gz

veeam_aiops-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+
+# Virtual envs / build
+.venv/
+dist/
+build/
+
+# uv
+uv.lock
+
+# Local config / secrets (never commit)
+*.env
+.env
+config.yaml
+
+# OS
+.DS_Store

veeam_aiops-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wei <zhouwei008@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

veeam_aiops-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: veeam-aiops
+Version: 0.1.0
+Summary: Veeam Backup & Replication AI-powered backup operations with a built-in governance harness (audit, budget, undo, risk tiers)
+Author-email: wei <zhouwei008@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: mcp[cli]<2.0,>=1.10
+Requires-Dist: python-dotenv<2.0,>=1.0
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: rich<16.0,>=13.0
+Requires-Dist: typer<1.0,>=0.12
+Description-Content-Type: text/markdown
+
+<!-- mcp-name: io.github.AIops-tools/veeam-aiops -->
+
+# Veeam AIops (preview)
+
+> **Disclaimer**: Community-maintained open-source project. **Not affiliated with, endorsed by, or sponsored by Veeam Software.** "Veeam" is a trademark of its owner. MIT licensed.
+
+AI-powered Veeam Backup & Replication operations with a **built-in governance
+harness** — unified audit log, policy engine, token/runaway budget guard,
+undo-token recording, and graduated-autonomy risk tiers. Self-contained: no
+external dependencies beyond `httpx` and the MCP SDK. Preview — not yet full
+coverage of every Veeam operation.
+
+## What works
+
+- **CLI** (`veeam-aiops ...`): `job list/get/start/stop/enable/disable`, `restore list-points/start`, `repository list`, `session list/get`, `backup list`, `doctor`, `mcp`.
+- **MCP server** (`veeam-aiops mcp` or `veeam-aiops-mcp`): **12 tools** (8 read, 4 write), every one wrapped with the bundled `@governed_tool` harness.
+- **Reversibility**: write ops with a clean inverse (job start/stop, enable/disable) record an inverse undo descriptor; the irreversible VM restore declares none and is tagged `high` risk.
+- **Async sessions**: Veeam jobs and restores run as sessions — poll progress with `session list` / `session get` (the runaway budget guard prevents poll loops from running away).
+
+## Quick start
+
+```bash
+uv tool install veeam-aiops
+mkdir -p ~/.veeam-aiops
+# create ~/.veeam-aiops/config.yaml with a targets: list
+# put passwords in ~/.veeam-aiops/.env  (chmod 600)
+veeam-aiops doctor
+```
+
+Example `~/.veeam-aiops/config.yaml`:
+
+```yaml
+targets:
+  - name: vbr-lab
+    host: 10.0.0.20
+    username: "DOMAIN\\backup-admin"
+    port: 9419
+    verify_ssl: false          # self-signed lab certs only
+```
+
+`~/.veeam-aiops/.env` (chmod 600): `VEEAM_VBR_LAB_PASSWORD=<password>`
+
+## Audit & safety
+
+All operations are logged to a local SQLite audit DB under `~/.veeam-aiops/`
+(relocatable via `VEEAM_AIOPS_HOME`). Every write tool passes through the
+governance harness: policy pre-check, token/runaway budget guard, graduated
+risk-tier gate, and audit logging. Destructive CLI commands (`job stop`,
+`restore start`) require double confirmation and support `--dry-run`.
+API-returned text is run through a prompt-injection sanitizer.
+
+License: MIT.

veeam_aiops-0.1.0/README.md

@@ -0,0 +1,52 @@
+<!-- mcp-name: io.github.AIops-tools/veeam-aiops -->
+
+# Veeam AIops (preview)
+
+> **Disclaimer**: Community-maintained open-source project. **Not affiliated with, endorsed by, or sponsored by Veeam Software.** "Veeam" is a trademark of its owner. MIT licensed.
+
+AI-powered Veeam Backup & Replication operations with a **built-in governance
+harness** — unified audit log, policy engine, token/runaway budget guard,
+undo-token recording, and graduated-autonomy risk tiers. Self-contained: no
+external dependencies beyond `httpx` and the MCP SDK. Preview — not yet full
+coverage of every Veeam operation.
+
+## What works
+
+- **CLI** (`veeam-aiops ...`): `job list/get/start/stop/enable/disable`, `restore list-points/start`, `repository list`, `session list/get`, `backup list`, `doctor`, `mcp`.
+- **MCP server** (`veeam-aiops mcp` or `veeam-aiops-mcp`): **12 tools** (8 read, 4 write), every one wrapped with the bundled `@governed_tool` harness.
+- **Reversibility**: write ops with a clean inverse (job start/stop, enable/disable) record an inverse undo descriptor; the irreversible VM restore declares none and is tagged `high` risk.
+- **Async sessions**: Veeam jobs and restores run as sessions — poll progress with `session list` / `session get` (the runaway budget guard prevents poll loops from running away).
+
+## Quick start
+
+```bash
+uv tool install veeam-aiops
+mkdir -p ~/.veeam-aiops
+# create ~/.veeam-aiops/config.yaml with a targets: list
+# put passwords in ~/.veeam-aiops/.env  (chmod 600)
+veeam-aiops doctor
+```
+
+Example `~/.veeam-aiops/config.yaml`:
+
+```yaml
+targets:
+  - name: vbr-lab
+    host: 10.0.0.20
+    username: "DOMAIN\\backup-admin"
+    port: 9419
+    verify_ssl: false          # self-signed lab certs only
+```
+
+`~/.veeam-aiops/.env` (chmod 600): `VEEAM_VBR_LAB_PASSWORD=<password>`
+
+## Audit & safety
+
+All operations are logged to a local SQLite audit DB under `~/.veeam-aiops/`
+(relocatable via `VEEAM_AIOPS_HOME`). Every write tool passes through the
+governance harness: policy pre-check, token/runaway budget guard, graduated
+risk-tier gate, and audit logging. Destructive CLI commands (`job stop`,
+`restore start`) require double confirmation and support `--dry-run`.
+API-returned text is run through a prompt-injection sanitizer.
+
+License: MIT.

veeam_aiops-0.1.0/RELEASE_NOTES.md

@@ -0,0 +1,22 @@
+# Release Notes
+
+## 0.1.0 (preview)
+
+Initial preview release of **veeam-aiops** — governed Veeam Backup & Replication
+operations for AI agents.
+
+- **12 MCP tools** (8 read, 4 write), every one wrapped with the bundled
+  `@governed_tool` governance harness (audit, policy, token/runaway budget,
+  undo-token recording, graduated risk tiers).
+- **Backup jobs**: list, get, start, stop, enable, disable.
+- **Restore**: list restore points, start a VM restore (high-risk skeleton).
+- **Repositories** and **stored backups**: list.
+- **Sessions**: list and get, for polling async job/restore progress.
+- **CLI** (`veeam-aiops ...`) with `--dry-run` and double-confirm on destructive
+  ops, plus `doctor` and an `mcp` stdio subcommand.
+- Veeam VBR REST API connection layer (OAuth2 password grant → bearer token,
+  `x-api-version: 1.1-rev1`, central HTTP-error translation into
+  `VeeamApiError` teaching messages).
+- Self-contained: bundled governance harness, no external skill-family
+  dependency. Dependencies: `httpx`, `typer`, `rich`, `pyyaml`,
+  `python-dotenv`, `mcp[cli]`.

veeam_aiops-0.1.0/SECURITY.md

@@ -0,0 +1,68 @@
+# Security Policy
+
+## Disclaimer
+
+Community-maintained open-source project. **Not affiliated with, endorsed by, or
+sponsored by Veeam Software.** "Veeam" is a trademark of its owner. Source is
+publicly auditable under the MIT license.
+
+## Reporting Vulnerabilities
+
+Report privately via a GitHub Security Advisory on
+[github.com/AIops-tools/Veeam-AIops](https://github.com/AIops-tools/Veeam-AIops/security/advisories)
+or email zhouwei008@gmail.com. Please do not open public issues for security
+reports.
+
+## Security Design
+
+### Credential Management
+- Per-target passwords live in `~/.veeam-aiops/.env` (chmod 600), never in
+  `config.yaml` and never in source. Variable pattern:
+  `VEEAM_<TARGET_NAME_UPPER>_PASSWORD`.
+- Passwords are exchanged for a short-lived OAuth2 bearer token at connect time;
+  the token is held only in memory (side-stored by connection id, never set as
+  an attribute on the HTTP client). Secrets are never logged or echoed; the
+  config file holds only host, port, username, and TLS settings.
+
+### Governed Operations
+Every MCP tool runs through the bundled `@governed_tool` harness
+(`veeam_aiops.governance`):
+- **Audit** — every call logged to a local SQLite DB under `~/.veeam-aiops/`
+  (relocatable via `VEEAM_AIOPS_HOME`), agent-attributed, secret-redacted.
+- **Token/runaway budget** — hard ceilings (`VEEAM_MAX_TOOL_CALLS` /
+  `VEEAM_MAX_TOOL_SECONDS`) plus an on-by-default guard that trips a tight
+  poll/retry loop, preventing unbounded API consumption (e.g. polling a slow
+  session).
+- **Graduated risk tiers** — `~/.veeam-aiops/rules.yaml` `risk_tiers` gate
+  writes by environment/tag; the highest tiers require a recorded approver.
+- **Undo-token recording** — reversible writes (job start/stop, enable/disable)
+  record an inverse descriptor so a change can be rolled back.
+
+### Destructive Operations
+`job stop` and `restore start` require double confirmation at the CLI layer and
+support `--dry-run`. The VM restore is irreversible (overwrites/creates a VM),
+tagged `risk_level=high`, and records no undo token.
+
+### SSL/TLS Verification
+`verify_ssl` defaults to true; disable only for self-signed lab certificates.
+
+### Prompt-Injection Protection
+All Veeam-API-returned text (job names, session results, descriptions) is passed
+through a `sanitize()` truncate + control-character strip before reaching the
+agent.
+
+### Network Scope
+No webhooks, no telemetry, no outbound calls beyond the configured Veeam B&R
+REST API endpoint. No post-install scripts or background services.
+
+## Static Analysis
+
+```bash
+uvx bandit -r veeam_aiops/ mcp_server/
+uv run ruff check .
+```
+
+## Supported Versions
+
+The latest released version receives security fixes. This is a preview (0.x);
+pin a version in production.

veeam_aiops-0.1.0/mcp_server/__init__.py

@@ -0,0 +1 @@
+"""MCP server package for veeam-aiops."""

veeam_aiops-0.1.0/mcp_server/_shared.py

@@ -0,0 +1,96 @@
+"""Shared MCP server primitives: the FastMCP instance, connection helper,
+error sanitisation, and the ``@tool_errors`` decorator.
+
+Tool modules under ``mcp_server/tools/`` import ``mcp`` from here and register
+their ``@mcp.tool()`` functions onto it. ``mcp_server/server.py`` then imports
+those modules and runs the server.
+
+Keep ``Optional[X]`` (never PEP 604 ``X | None``) in any FastMCP-reflected
+tool signature — on older mcp/pydantic the union eval'd to ``types.UnionType``
+crashes FastMCP's ``issubclass`` check.
+"""
+
+import functools
+import logging
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Optional
+
+from mcp.server.fastmcp import FastMCP
+
+from veeam_aiops.config import load_config
+from veeam_aiops.connection import ConnectionManager, VeeamApiError
+from veeam_aiops.governance import sanitize
+
+logger = logging.getLogger(__name__)
+
+_DOCTOR_HINT = "Run 'veeam-aiops doctor' to verify connectivity and credentials."
+
+
+def _safe_error(exc: Exception, tool: str) -> str:
+    """Return an agent-safe error string; log full detail server-side only."""
+    logger.error("Tool %s failed", tool, exc_info=True)
+    _passthrough = (
+        ValueError,
+        FileNotFoundError,
+        KeyError,
+        PermissionError,
+        TimeoutError,
+        ConnectionError,
+        VeeamApiError,
+    )
+    if isinstance(exc, _passthrough):
+        return sanitize(str(exc), 300)
+    return f"{type(exc).__name__}: operation failed."
+
+
+def tool_errors(shape: str = "dict") -> Callable:
+    """Wrap a tool body in the canonical try/except → ``_safe_error`` pattern.
+
+    Place this *between* ``@governed_tool`` and the function so the audit
+    decorator and FastMCP still see the original signature.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        name = func.__name__
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:  # noqa: BLE001 — sanitised below
+                msg = _safe_error(e, name)
+                if shape == "list":
+                    return [{"error": msg, "hint": _DOCTOR_HINT}]
+                if shape == "str":
+                    return f"Error: {msg} {_DOCTOR_HINT}"
+                return {"error": msg, "hint": _DOCTOR_HINT}
+
+        return wrapper
+
+    return decorator
+
+
+mcp = FastMCP(
+    "veeam-aiops",
+    instructions=(
+        "Veeam Backup & Replication operations (preview): backup jobs "
+        "(list/get, start/stop, enable/disable), restore points + VM restore, "
+        "backup repositories, stored backups, and async sessions for polling "
+        "job/restore progress. Every tool runs through the veeam-aiops governance "
+        "harness (audit / budget / risk-tier / undo)."
+    ),
+)
+
+_conn_mgr: Optional[ConnectionManager] = None
+
+
+def _get_connection(target: Optional[str] = None) -> Any:
+    """Return a Veeam connection, lazily initialising the manager."""
+    global _conn_mgr  # noqa: PLW0603
+    if _conn_mgr is None:
+        config_path_str = os.environ.get("VEEAM_AIOPS_CONFIG")
+        config_path = Path(config_path_str) if config_path_str else None
+        _conn_mgr = ConnectionManager(load_config(config_path))
+    return _conn_mgr.connect(target)

veeam_aiops-0.1.0/mcp_server/server.py

@@ -0,0 +1,34 @@
+"""MCP server wrapping Veeam AIops operations (stdio transport).
+
+Thin adapter layer: each ``@mcp.tool()`` function (in ``mcp_server/tools/``)
+delegates to the ``veeam_aiops`` ops package and is wrapped with the
+veeam-aiops ``@governed_tool`` harness (audit / budget / undo / risk-tier).
+
+Standalone, self-governed Veeam Backup & Replication operations (preview).
+For Veeam Backup & Replication only.
+
+Source: https://github.com/AIops-tools/Veeam-AIops
+License: MIT
+"""
+
+import logging
+
+from mcp_server._shared import _safe_error, mcp, tool_errors
+
+# Importing the tool modules registers every @mcp.tool() onto the shared
+# `mcp` instance. Order does not matter; each module is self-contained.
+from mcp_server.tools import (  # noqa: F401 — side effects
+    backups,
+    jobs,
+    repositories,
+    restore,
+    sessions,
+)
+
+__all__ = ["mcp", "main", "_safe_error", "tool_errors"]
+
+
+def main() -> None:
+    """Run the MCP server over stdio."""
+    logging.basicConfig(level=logging.INFO)
+    mcp.run(transport="stdio")

veeam_aiops-0.1.0/mcp_server/tools/__init__.py

@@ -0,0 +1 @@
+"""MCP tool modules. Importing each registers its @mcp.tool() functions."""

veeam_aiops-0.1.0/mcp_server/tools/backups.py

@@ -0,0 +1,19 @@
+"""Stored-backup MCP tools (read-only)."""
+
+from typing import Optional
+
+from mcp_server._shared import _get_connection, mcp, tool_errors
+from veeam_aiops.governance import governed_tool
+from veeam_aiops.ops import backups as ops
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("list")
+def backup_list(target: Optional[str] = None) -> list:
+    """[READ] List stored backups with id, name, type, creationTime.
+
+    Args:
+        target: Veeam target name from config; omit to use the default.
+    """
+    return ops.list_backups(_get_connection(target))

veeam_aiops-0.1.0/mcp_server/tools/jobs.py

@@ -0,0 +1,127 @@
+"""Backup job MCP tools: list/get, start/stop, enable/disable.
+
+Every tool is wrapped with ``@governed_tool`` (the veeam-aiops harness):
+policy pre-check, budget/runaway guard, graduated-autonomy risk-tier gate,
+audit logging to ~/.veeam-aiops/audit.db, and undo-token recording. Write tools
+with a clean inverse pass an ``undo=`` lambda so the harness records a reversal
+descriptor to the undo store (start↔stop, enable↔disable).
+"""
+
+from typing import Optional
+
+from mcp_server._shared import _get_connection, mcp, tool_errors
+from veeam_aiops.governance import governed_tool
+from veeam_aiops.ops import jobs as ops
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("list")
+def job_list(target: Optional[str] = None) -> list:
+    """[READ] List backup jobs with id, name, type, status, lastResult.
+
+    Use job_get for full detail of a single job.
+
+    Args:
+        target: Veeam target name from config; omit to use the default.
+    """
+    return ops.list_jobs(_get_connection(target))
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("dict")
+def job_get(job_id: str, target: Optional[str] = None) -> dict:
+    """[READ] Return detail for a single backup job by id.
+
+    Args:
+        job_id: Veeam job id (see job_list).
+        target: Veeam target name from config.
+    """
+    return ops.get_job(_get_connection(target), job_id)
+
+
+@mcp.tool()
+@governed_tool(
+    risk_level="medium",
+    undo=lambda params, result: {
+        "tool": "job_stop",
+        "params": {"job_id": params.get("job_id")},
+        "skill": "veeam-aiops",
+        "note": "Inverse of job_start: stop the running job.",
+    },
+)
+@tool_errors("dict")
+def job_start(job_id: str, target: Optional[str] = None) -> dict:
+    """[WRITE] Start a backup job. Runs as an async session. Inverse: job_stop.
+
+    Poll progress with session_list / session_get; do not re-issue.
+
+    Args:
+        job_id: Veeam job id.
+        target: Veeam target name from config.
+    """
+    return ops.start_job(_get_connection(target), job_id)
+
+
+@mcp.tool()
+@governed_tool(
+    risk_level="medium",
+    undo=lambda params, result: {
+        "tool": "job_start",
+        "params": {"job_id": params.get("job_id")},
+        "skill": "veeam-aiops",
+        "note": "Inverse of job_stop: start the job again.",
+    },
+)
+@tool_errors("dict")
+def job_stop(job_id: str, target: Optional[str] = None) -> dict:
+    """[WRITE] Stop a running backup job. Inverse: job_start.
+
+    Args:
+        job_id: Veeam job id.
+        target: Veeam target name from config.
+    """
+    return ops.stop_job(_get_connection(target), job_id)
+
+
+@mcp.tool()
+@governed_tool(
+    risk_level="medium",
+    undo=lambda params, result: {
+        "tool": "job_disable",
+        "params": {"job_id": params.get("job_id")},
+        "skill": "veeam-aiops",
+        "note": "Inverse of job_enable: disable the job again.",
+    },
+)
+@tool_errors("dict")
+def job_enable(job_id: str, target: Optional[str] = None) -> dict:
+    """[WRITE] Enable a backup job (clears the disabled flag). Inverse: job_disable.
+
+    Args:
+        job_id: Veeam job id.
+        target: Veeam target name from config.
+    """
+    return ops.enable_job(_get_connection(target), job_id)
+
+
+@mcp.tool()
+@governed_tool(
+    risk_level="medium",
+    undo=lambda params, result: {
+        "tool": "job_enable",
+        "params": {"job_id": params.get("job_id")},
+        "skill": "veeam-aiops",
+        "note": "Inverse of job_disable: enable the job again.",
+    },
+)
+@tool_errors("dict")
+def job_disable(job_id: str, target: Optional[str] = None) -> dict:
+    """[WRITE] Disable a backup job (skips scheduled runs). Inverse: job_enable.
+
+    Args:
+        job_id: Veeam job id.
+        target: Veeam target name from config.
+    """
+    return ops.disable_job(_get_connection(target), job_id)

veeam_aiops-0.1.0/mcp_server/tools/repositories.py

@@ -0,0 +1,19 @@
+"""Backup repository MCP tools (read-only)."""
+
+from typing import Optional
+
+from mcp_server._shared import _get_connection, mcp, tool_errors
+from veeam_aiops.governance import governed_tool
+from veeam_aiops.ops import repositories as ops
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("list")
+def repository_list(target: Optional[str] = None) -> list:
+    """[READ] List backup repositories with id, name, type, path.
+
+    Args:
+        target: Veeam target name from config; omit to use the default.
+    """
+    return ops.list_repositories(_get_connection(target))

veeam_aiops-0.1.0/mcp_server/tools/restore.py

@@ -0,0 +1,39 @@
+"""Restore MCP tools: list restore points, start a VM restore.
+
+start_vm_restore is high-risk with NO undo token — restoring a VM overwrites
+or creates one and cannot be reversed by the harness.
+"""
+
+from typing import Optional
+
+from mcp_server._shared import _get_connection, mcp, tool_errors
+from veeam_aiops.governance import governed_tool
+from veeam_aiops.ops import restore as ops
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("list")
+def restore_list_points(target: Optional[str] = None) -> list:
+    """[READ] List available restore points (id, name, creationTime, type).
+
+    Args:
+        target: Veeam target name from config; omit to use the default.
+    """
+    return ops.list_restore_points(_get_connection(target))
+
+
+@mcp.tool()
+@governed_tool(risk_level="high")
+@tool_errors("dict")
+def start_vm_restore(restore_point_id: str, target: Optional[str] = None) -> dict:
+    """[WRITE] Start a VM restore from a restore point. IRREVERSIBLE — no undo token.
+
+    Overwrites or creates a VM; confirm with the user before calling. Runs as an
+    async session — poll with session_list / session_get.
+
+    Args:
+        restore_point_id: Restore point id (see restore_list_points).
+        target: Veeam target name from config.
+    """
+    return ops.start_vm_restore(_get_connection(target), restore_point_id)

veeam_aiops-0.1.0/mcp_server/tools/sessions.py

@@ -0,0 +1,35 @@
+"""Session MCP tools (read-only): poll async job/restore progress."""
+
+from typing import Optional
+
+from mcp_server._shared import _get_connection, mcp, tool_errors
+from veeam_aiops.governance import governed_tool
+from veeam_aiops.ops import sessions as ops
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("list")
+def session_list(target: Optional[str] = None) -> list:
+    """[READ] List recent sessions with id, name, type, state, result.
+
+    Args:
+        target: Veeam target name from config; omit to use the default.
+    """
+    return ops.list_sessions(_get_connection(target))
+
+
+@mcp.tool()
+@governed_tool(risk_level="low")
+@tool_errors("dict")
+def session_get(session_id: str, target: Optional[str] = None) -> dict:
+    """[READ] Poll one session by id to check job/restore progress.
+
+    Use after job_start or start_vm_restore to follow the operation instead of
+    re-issuing it.
+
+    Args:
+        session_id: Veeam session id (see session_list).
+        target: Veeam target name from config.
+    """
+    return ops.get_session(_get_connection(target), session_id)