splunkctl 0.5.0__tar.gz → 0.6.0__tar.gz

{splunkctl-0.5.0 → splunkctl-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splunkctl
-Version: 0.5.0
+Version: 0.6.0
 Summary: CLI tool for Splunk Enterprise SIEM operations.
 Author: dannyota
 License-Expression: Apache-2.0

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl/__init__.py

@@ -1,3 +1,3 @@
 """CLI tool for Splunk Enterprise SIEM operations."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl/commands/knowledge.py

@@ -17,6 +17,7 @@ uses.
 """
 
 import re
+import urllib.parse
 from typing import Any
 
 import click
@@ -275,9 +276,15 @@ def eventtypes_get(ctx: click.Context, name: str, app: str | None) -> None:
 # each key inside the stanza is a tag name whose value is enabled/disabled.
 # `disabled` itself is the stanza-level flag, not a tag, and eai:* keys are
 # read-only REST metadata — both are excluded from the tag-name views below.
+# REST returns stanza names URL-encoded (`eventtype=cim%3Aauth`); the views
+# decode them, and `tags get` accepts either form.
 _TAG_METADATA_KEYS = {"disabled"}
 
 
+def _decode_stanza(name: str) -> str:
+    return urllib.parse.unquote(name)
+
+
 def _is_tag_key(key: str) -> bool:
     return key not in _TAG_METADATA_KEYS and not key.startswith("eai:")
 
@@ -335,7 +342,7 @@ def tags_list(
     )
     rows: list[dict[str, Any]] = [
         {
-            "field_value": s.name,
+            "field_value": _decode_stanza(s.name),
             "tags": ";".join(_enabled_tag_names(dict(s.content))),
             "app": dict(s.access).get("app", ""),
         }
@@ -359,9 +366,16 @@ def tags_get(ctx: click.Context, field_value: str, app: str | None) -> None:
     try:
         entity = conf_ops.get_stanza(client, "tags", field_value, app=app)
     except KeyError:
-        output.error(
-            f"Stanza '{field_value}' not found in tags.conf.", kind="not_found"
-        )
-        ctx.exit(1)
-        return
-    output.render(ctx, {"name": entity.name, **_tag_states(dict(entity.content))})
+        encoded = urllib.parse.quote(field_value, safe="=")
+        try:
+            entity = conf_ops.get_stanza(client, "tags", encoded, app=app)
+        except KeyError:
+            output.error(
+                f"Stanza '{field_value}' not found in tags.conf.", kind="not_found"
+            )
+            ctx.exit(1)
+            return
+    output.render(
+        ctx,
+        {"name": _decode_stanza(entity.name), **_tag_states(dict(entity.content))},
+    )

splunkctl-0.6.0/splunkctl/commands/server.py

@@ -0,0 +1,179 @@
+"""Server operations — messages, license, KV store, topology health."""
+
+import json
+from datetime import UTC, datetime
+from typing import Any
+
+import click
+
+from splunkctl import guard, output
+from splunkctl.client import get_client
+
+
+def _human_bytes(n: int) -> str:
+    size = float(n)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(size) < 1024 or unit == "TB":
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{n} B"
+
+
+@click.group("server")
+def server_group() -> None:
+    """Server operations — messages, license, KV store, topology health."""
+
+
+@server_group.command("messages")
+@guard.guarded
+@click.option("--dismiss", default=None, help="Delete a message by name.")
+@click.pass_context
+def messages(ctx: click.Context, dismiss: str | None) -> None:
+    """List system messages, or dismiss one with --dismiss NAME --yes."""
+    client = get_client(ctx)
+    svc = client.service
+
+    if dismiss is not None:
+        if not guard.check(ctx, f"Dismiss system message '{dismiss}'"):
+            return
+        try:
+            msg = svc.messages[dismiss]
+        except KeyError:
+            output.error(f"Message '{dismiss}' not found.", kind="not_found")
+            ctx.exit(1)
+            return
+        msg.delete()
+        output.info(f"Message '{dismiss}' dismissed.")
+        return
+
+    rows: list[dict[str, Any]] = []
+    for msg in svc.messages.list():
+        c: dict[str, Any] = msg.content
+        rows.append(
+            {
+                "name": msg.name,
+                "severity": c.get("severity", ""),
+                "message": c.get("message", ""),
+                "time_created": c.get("timeCreated_iso", c.get("timeCreated", "")),
+            }
+        )
+    output.render(ctx, rows, empty="No system messages.")
+
+
+# Splunk encodes "never expires" as INT32_MAX seconds.
+_PERPETUAL = 2**31 - 1
+
+
+def _render_license_usage(ctx: click.Context, svc: Any) -> None:
+    """Render today's indexed volume vs quota plus license expiry."""
+    resp = svc.get("/services/licenser/usage", output_mode="json")
+    body: dict[str, Any] = json.loads(resp.body.read())
+    entries: list[dict[str, Any]] = body.get("entry", [])
+    c: dict[str, Any] = entries[0].get("content", {}) if entries else {}
+    used = int(c.get("slaves_usage_bytes", 0))
+    quota = int(c.get("quota", 0))
+    pct = round(used / quota * 100, 1) if quota else 0.0
+
+    resp = svc.get("/services/licenser/licenses", output_mode="json")
+    lic_body: dict[str, Any] = json.loads(resp.body.read())
+    valid = 0
+    expiries: list[int] = []
+    for entry in lic_body.get("entry", []):
+        lc: dict[str, Any] = entry.get("content", {})
+        if lc.get("status") == "VALID":
+            valid += 1
+        exp = int(lc.get("expiration_time", _PERPETUAL))
+        if exp < _PERPETUAL:
+            expiries.append(exp)
+    soonest = (
+        datetime.fromtimestamp(min(expiries), tz=UTC).strftime("%Y-%m-%d")
+        if expiries
+        else "never"
+    )
+
+    output.render(
+        ctx,
+        {
+            "used": _human_bytes(used),
+            "quota": _human_bytes(quota),
+            "pct_used": pct,
+            "licenses_valid": valid,
+            "soonest_expiry": soonest,
+        },
+    )
+
+
+@server_group.command("license")
+@click.option(
+    "--usage",
+    "show_usage",
+    is_flag=True,
+    help="Today's indexed volume vs quota and soonest license expiry.",
+)
+@click.pass_context
+def license_pools(ctx: click.Context, *, show_usage: bool) -> None:
+    """Show license pool usage, or daily volume and expiry with --usage."""
+    client = get_client(ctx)
+    if show_usage:
+        _render_license_usage(ctx, client.service)
+        return
+
+    resp = client.service.get("/services/licenser/pools", output_mode="json")
+    body: dict[str, Any] = json.loads(resp.body.read())
+
+    rows: list[dict[str, Any]] = []
+    for entry in body.get("entry", []):
+        c: dict[str, Any] = entry.get("content", {})
+        used = int(c.get("used_bytes", 0))
+        quota = int(c.get("effective_quota", 0))
+        rows.append(
+            {
+                "title": entry.get("name", ""),
+                "used": _human_bytes(used),
+                "quota": _human_bytes(quota),
+            }
+        )
+    output.render(ctx, rows, empty="No license pools found.")
+
+
+@server_group.command("kvstore")
+@click.pass_context
+def kvstore_status(ctx: click.Context) -> None:
+    """Show KV store status."""
+    client = get_client(ctx)
+    resp = client.service.get("/services/kvstore/status", output_mode="json")
+    body: dict[str, Any] = json.loads(resp.body.read())
+
+    entries: list[dict[str, Any]] = body.get("entry", [])
+    if not entries:
+        output.error("No KV store status available.")
+        ctx.exit(1)
+        return
+
+    c: dict[str, Any] = entries[0].get("content", {})
+    current: dict[str, Any] = c.get("current") or {}
+    status_raw = current.get("status")
+    status = "unknown" if not status_raw else str(status_raw).lower()
+    row: dict[str, Any] = {
+        "status": status,
+        "port": current.get("port", ""),
+        "version": current.get("version", ""),
+        "storage_engine": current.get("storageEngine", ""),
+        "db_path": current.get("dbPath", ""),
+    }
+    output.render(ctx, row)
+
+
+from splunkctl.commands.server_topology import (  # noqa: E402
+    cluster_health,
+    deployment_health,
+    health_report,
+    search_peers,
+    shcluster_health,
+)
+
+server_group.add_command(cluster_health)
+server_group.add_command(shcluster_health)
+server_group.add_command(deployment_health)
+server_group.add_command(health_report)
+server_group.add_command(search_peers)

splunkctl-0.5.0/splunkctl/commands/server.py → splunkctl-0.6.0/splunkctl/commands/server_topology.py

@@ -1,23 +1,14 @@
-"""Server operations — messages, license, KV store, topology health."""
+"""Server topology & health commands (cluster, SHC, deployment, peers)."""
 
 import json
 from typing import Any
 
 import click
 
-from splunkctl import guard, output
+from splunkctl import output
 from splunkctl.client import get_client
 
 
-def _human_bytes(n: int) -> str:
-    size = float(n)
-    for unit in ("B", "KB", "MB", "GB", "TB"):
-        if abs(size) < 1024 or unit == "TB":
-            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
-        size /= 1024
-    return f"{n} B"
-
-
 def _is_not_enabled(exc: Exception) -> bool:
     """True when an HTTPError signals a feature is not enabled (clean exit 0).
 
@@ -35,111 +26,41 @@ def _is_not_enabled(exc: Exception) -> bool:
     return "not enabled" in msg
 
 
-def _rest_get(svc: Any, path: str) -> dict[str, Any]:
-    """GET a REST path and parse JSON. Thin wrapper for topology reads."""
-    resp = svc.get(path, output_mode="json")
-    body: dict[str, Any] = json.loads(resp.body.read())
-    return body
-
-
-@click.group("server")
-def server_group() -> None:
-    """Server operations — messages, license, KV store, topology health."""
-
-
-@server_group.command("messages")
-@guard.guarded
-@click.option("--dismiss", default=None, help="Delete a message by name.")
-@click.pass_context
-def messages(ctx: click.Context, dismiss: str | None) -> None:
-    """List system messages, or dismiss one with --dismiss NAME --yes."""
-    client = get_client(ctx)
-    svc = client.service
-
-    if dismiss is not None:
-        if not guard.check(ctx, f"Dismiss system message '{dismiss}'"):
-            return
-        try:
-            msg = svc.messages[dismiss]
-        except KeyError:
-            output.error(f"Message '{dismiss}' not found.", kind="not_found")
-            ctx.exit(1)
-            return
-        msg.delete()
-        output.info(f"Message '{dismiss}' dismissed.")
-        return
-
-    rows: list[dict[str, Any]] = []
-    for msg in svc.messages.list():
-        c: dict[str, Any] = msg.content
-        rows.append(
-            {
-                "name": msg.name,
-                "severity": c.get("severity", ""),
-                "message": c.get("message", ""),
-                "time_created": c.get("timeCreated_iso", c.get("timeCreated", "")),
-            }
-        )
-    output.render(ctx, rows, empty="No system messages.")
+def _disabled_detail(exc: Exception) -> str:
+    """Human-readable message from a feature-disabled HTTPError.
 
+    Splunk's error body is JSON (``{"messages": [{"text": ...}]}``) when
+    the request asked for ``output_mode=json``, XML otherwise; ``str(exc)``
+    would embed the raw bytes literal for JSON bodies.
+    """
+    raw = getattr(exc, "body", b"") or b""
+    body = raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else raw
+    try:
+        msgs = json.loads(body).get("messages", [])
+        texts = [m.get("text") for m in msgs if isinstance(m, dict)]
+        if any(texts):
+            return "; ".join(t for t in texts if t)
+    except (json.JSONDecodeError, AttributeError):
+        pass
+    try:
+        from defusedxml.ElementTree import fromstring
 
-@server_group.command("license")
-@click.pass_context
-def license_pools(ctx: click.Context) -> None:
-    """Show license pool usage."""
-    client = get_client(ctx)
-    resp = client.service.get("/services/licenser/pools", output_mode="json")
-    body: dict[str, Any] = json.loads(resp.body.read())
-
-    rows: list[dict[str, Any]] = []
-    for entry in body.get("entry", []):
-        c: dict[str, Any] = entry.get("content", {})
-        used = int(c.get("used_bytes", 0))
-        quota = int(c.get("effective_quota", 0))
-        rows.append(
-            {
-                "title": entry.get("name", ""),
-                "used": _human_bytes(used),
-                "quota": _human_bytes(quota),
-            }
-        )
-    output.render(ctx, rows, empty="No license pools found.")
+        text = fromstring(body).findtext("./messages/msg")
+        if text:
+            return text
+    except Exception:  # noqa: BLE001, S110
+        pass
+    return str(getattr(exc, "reason", "") or exc)
 
 
-@server_group.command("kvstore")
-@click.pass_context
-def kvstore_status(ctx: click.Context) -> None:
-    """Show KV store status."""
-    client = get_client(ctx)
-    resp = client.service.get("/services/kvstore/status", output_mode="json")
+def _rest_get(svc: Any, path: str, **params: Any) -> dict[str, Any]:
+    """GET a REST path and parse JSON. Thin wrapper for topology reads."""
+    resp = svc.get(path, output_mode="json", **params)
     body: dict[str, Any] = json.loads(resp.body.read())
-
-    entries: list[dict[str, Any]] = body.get("entry", [])
-    if not entries:
-        output.error("No KV store status available.")
-        ctx.exit(1)
-        return
-
-    c: dict[str, Any] = entries[0].get("content", {})
-    current: dict[str, Any] = c.get("current") or {}
-    status_raw = current.get("status")
-    status = "unknown" if not status_raw else str(status_raw).lower()
-    row: dict[str, Any] = {
-        "status": status,
-        "port": current.get("port", ""),
-        "version": current.get("version", ""),
-        "storage_engine": current.get("storageEngine", ""),
-        "db_path": current.get("dbPath", ""),
-    }
-    output.render(ctx, row)
-
-
-# ---------------------------------------------------------------------------
-# Topology health (read-only)
-# ---------------------------------------------------------------------------
+    return body
 
 
-@server_group.command("cluster")
+@click.command("cluster")
 @click.pass_context
 def cluster_health(ctx: click.Context) -> None:
     """Indexer cluster health — mode, peers, SF/RF status.
@@ -156,7 +77,7 @@ def cluster_health(ctx: click.Context) -> None:
         info_body = _rest_get(svc, f"/services/{prefix}/info")
     except Exception as exc:
         if _is_not_enabled(exc):
-            output.render(ctx, {"mode": "disabled", "detail": str(exc)})
+            output.render(ctx, {"mode": "disabled", "detail": _disabled_detail(exc)})
             return
         # 404 -> try legacy master prefix
         if type(exc).__name__ == "HTTPError" and getattr(exc, "status", 0) == 404:
@@ -165,7 +86,10 @@ def cluster_health(ctx: click.Context) -> None:
                 info_body = _rest_get(svc, f"/services/{prefix}/info")
             except Exception as inner:
                 if _is_not_enabled(inner):
-                    output.render(ctx, {"mode": "disabled", "detail": str(inner)})
+                    output.render(
+                        ctx,
+                        {"mode": "disabled", "detail": _disabled_detail(inner)},
+                    )
                     return
                 raise
         else:
@@ -210,7 +134,7 @@ def cluster_health(ctx: click.Context) -> None:
     output.render(ctx, rows, empty="No cluster info available.")
 
 
-@server_group.command("shcluster")
+@click.command("shcluster")
 @click.pass_context
 def shcluster_health(ctx: click.Context) -> None:
     """Search head cluster health — captain, members, replication.
@@ -224,7 +148,7 @@ def shcluster_health(ctx: click.Context) -> None:
         body = _rest_get(svc, "/services/shcluster/status")
     except Exception as exc:
         if _is_not_enabled(exc):
-            output.render(ctx, {"mode": "disabled", "detail": str(exc)})
+            output.render(ctx, {"mode": "disabled", "detail": _disabled_detail(exc)})
             return
         raise
 
@@ -258,7 +182,7 @@ def shcluster_health(ctx: click.Context) -> None:
     output.render(ctx, rows, empty="No SHC status available.")
 
 
-@server_group.command("deployment")
+@click.command("deployment")
 @click.pass_context
 def deployment_health(ctx: click.Context) -> None:
     """Deployment server clients — count, last check-in.
@@ -273,7 +197,7 @@ def deployment_health(ctx: click.Context) -> None:
         body = _rest_get(svc, "/services/deployment/server/clients")
     except Exception as exc:
         if _is_not_enabled(exc):
-            output.render(ctx, {"status": "disabled", "detail": str(exc)})
+            output.render(ctx, {"status": "disabled", "detail": _disabled_detail(exc)})
             return
         raise
 
@@ -300,3 +224,89 @@ def deployment_health(ctx: click.Context) -> None:
         )
 
     output.render(ctx, rows)
+
+
+# ---------------------------------------------------------------------------
+# splunkd health report & distributed-search peers
+# ---------------------------------------------------------------------------
+
+
+def _reason_text(node: dict[str, Any]) -> str:
+    """Join a health node's nested reason strings, if any."""
+    reasons = node.get("reasons")
+    if not isinstance(reasons, dict):
+        return ""
+    texts: list[str] = []
+    for bucket in reasons.values():
+        if not isinstance(bucket, dict):
+            continue
+        for item in bucket.values():
+            if isinstance(item, dict) and item.get("reason"):
+                texts.append(str(item["reason"]))
+    return "; ".join(texts)
+
+
+def _walk_health(node: dict[str, Any], label: str, rows: list[dict[str, Any]]) -> None:
+    """Flatten the health feature tree into one row per component."""
+    rows.append(
+        {
+            "component": label,
+            "health": node.get("health", ""),
+            "reasons": _reason_text(node),
+        }
+    )
+    features = node.get("features") or {}
+    for child_name, child in sorted(features.items()):
+        if not isinstance(child, dict):
+            continue
+        child_label = child_name if label == "splunkd" else f"{label} / {child_name}"
+        _walk_health(child, child_label, rows)
+
+
+@click.command("health")
+@click.pass_context
+def health_report(ctx: click.Context) -> None:
+    """Component-level splunkd health report (scheduler, disk, KV store...).
+
+    Flattens the health-report feature tree into one row per component;
+    nested feature names join with " / ". This command reports — it does
+    not gate: red components still exit 0.
+    """
+    client = get_client(ctx)
+    body = _rest_get(client.service, "/services/server/health/splunkd/details")
+    entries: list[dict[str, Any]] = body.get("entry", [])
+    rows: list[dict[str, Any]] = []
+    if entries:
+        _walk_health(entries[0].get("content", {}), "splunkd", rows)
+    output.render(ctx, rows, empty="No health report available.")
+
+
+@click.command("search-peers")
+@click.pass_context
+def search_peers(ctx: click.Context) -> None:
+    """Distributed-search peers — status, replication, version.
+
+    Lists every search peer this instance fans searches out to. Empty on
+    a standalone instance (exit 0).
+    """
+    client = get_client(ctx)
+    try:
+        body = _rest_get(client.service, "/services/search/distributed/peers", count=-1)
+    except Exception as exc:
+        if _is_not_enabled(exc):
+            output.render(ctx, {"status": "disabled", "detail": _disabled_detail(exc)})
+            return
+        raise
+
+    rows: list[dict[str, Any]] = []
+    for entry in body.get("entry", []):
+        c: dict[str, Any] = entry.get("content", {})
+        rows.append(
+            {
+                "peer": c.get("peerName", entry.get("name", "")),
+                "status": c.get("status", ""),
+                "replication_status": c.get("replicationStatus", ""),
+                "version": c.get("version", ""),
+            }
+        )
+    output.render(ctx, rows, empty="No search peers (standalone instance).")

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl/mcp/server.py

@@ -9,10 +9,14 @@ import sys
 from typing import Any
 
 from mcp.server.fastmcp import Context, FastMCP
+from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase, FuncMetadata
 from mcp.types import ToolAnnotations
+from pydantic import ConfigDict
 
+from splunkctl import __version__
 from splunkctl.mcp.resources import load_guides
 from splunkctl.mcp.tools import (
+    SKIP_PARAMS,
     ToolEntry,
     ToolIndex,
     build_tool_index,
@@ -32,9 +36,7 @@ pass yes=true to apply (dry-run by default)."""
 
 _FORCE_FLAGS = ["--json"]
 
-_STRIP_PARAMS = frozenset(
-    {"yes", "json", "debug", "format", "fields", "out", "config", "profile", "timeout"}
-)
+_STRIP_PARAMS = SKIP_PARAMS
 
 
 def _exec_cli(args: list[str]) -> str:
@@ -63,17 +65,36 @@ def _split_command(raw: str) -> list[str]:
         return raw.split()
 
 
+def _coerce_array(entry: ToolEntry, pname: str, value: Any) -> Any:
+    """Parse a JSON-encoded array string for array-typed params.
+
+    Some MCP clients serialize list arguments as JSON strings; the
+    pass-through arg model does no pre-parsing, so unwrap here.
+    """
+    prop = entry.schema.get("properties", {}).get(pname, {})
+    if prop.get("type") == "array" and isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError:
+            return value
+        if isinstance(parsed, list):
+            return parsed
+    return value
+
+
 def _build_cli_args(entry: ToolEntry, params: dict[str, Any]) -> list[str]:
     """Convert typed tool parameters to CLI arg list."""
     args = list(entry.cmd_path)
-    positional_values: list[str] = []
-    for pname, value in params.items():
+    positional: dict[str, list[str]] = {}
+    for pname, raw in params.items():
         if pname in _STRIP_PARAMS:
-            if pname == "yes" and value:
+            if pname == "yes" and raw:
                 args.append("--yes")
             continue
+        value = _coerce_array(entry, pname, raw)
         if pname in entry.positional:
-            positional_values.append(str(value))
+            items = value if isinstance(value, list) else [value]
+            positional[pname] = [str(v) for v in items]
             continue
         flag = f"--{pname.replace('_', '-')}"
         if isinstance(value, bool):
@@ -84,7 +105,10 @@ def _build_cli_args(entry: ToolEntry, params: dict[str, Any]) -> list[str]:
                 args.extend([flag, str(item)])
         else:
             args.extend([flag, str(value)])
-    args.extend(positional_values)
+    for pname in entry.arg_order:
+        args.extend(positional.pop(pname, []))
+    for leftovers in positional.values():
+        args.extend(leftovers)
     return args
 
 
@@ -96,6 +120,7 @@ def create_server() -> FastMCP:
         name="splunkctl",
         instructions=_INSTRUCTIONS,
     )
+    mcp._mcp_server.version = __version__
 
     from mcp.server.lowlevel.server import NotificationOptions
 
@@ -147,7 +172,7 @@ def create_server() -> FastMCP:
         if entry is None:
             return f"Unknown command: {command}"
 
-        if tool_name not in focused.get("_usage", []):
+        if not any(tool_name in names for names in focused.values()):
             _register_tool(mcp, entry)
             focused.setdefault("_usage", []).append(tool_name)
             await ctx.session.send_tool_list_changed()
@@ -290,6 +315,23 @@ def create_server() -> FastMCP:
     return mcp
 
 
+class _PassThroughArgs(ArgModelBase):
+    """Arg model that forwards arbitrary fields to the CLI unvalidated.
+
+    Focused tools advertise a Click-derived JSON Schema, but runtime
+    validation belongs to Click itself — the subprocess rejects bad args
+    with a usage error. FastMCP's default ``func_metadata`` would instead
+    validate against the runner's ``**kwargs`` signature, which no client
+    payload can ever satisfy.
+    """
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+    def model_dump_one_level(self) -> dict[str, Any]:
+        """Return the extra (client-sent) fields as-is."""
+        return dict(self.__pydantic_extra__ or {})
+
+
 def _register_tool(mcp: FastMCP, entry: ToolEntry) -> None:
     """Register a focused tool that executes via subprocess.
 
@@ -297,7 +339,6 @@ def _register_tool(mcp: FastMCP, entry: ToolEntry) -> None:
     Schema instead of FastMCP's auto-generation from function signatures.
     """
     from mcp.server.fastmcp.tools import Tool as MCPTool
-    from mcp.server.fastmcp.utilities.func_metadata import func_metadata
 
     annotations = ToolAnnotations(
         readOnlyHint=not entry.guarded,
@@ -314,7 +355,7 @@ def _register_tool(mcp: FastMCP, entry: ToolEntry) -> None:
         title=None,
         description=entry.description,
         parameters=entry.schema,
-        fn_metadata=func_metadata(_runner),
+        fn_metadata=FuncMetadata(arg_model=_PassThroughArgs),
         is_async=True,
         context_kwarg=None,
         annotations=annotations,

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl/mcp/tools.py

@@ -6,12 +6,13 @@ import click
 
 from splunkctl.guard import is_guarded
 
-_SKIP_FLAGS = frozenset(
+SKIP_PARAMS = frozenset(
     {
         "help",
         "json",
         "use_json",
         "fmt",
+        "format",
         "fields",
         "out",
         "debug",
@@ -22,10 +23,16 @@ _SKIP_FLAGS = frozenset(
     }
 )
 
+_YES_PROP: dict[str, Any] = {
+    "type": "boolean",
+    "default": False,
+    "description": "Apply the mutation (omit or false = dry-run preview).",
+}
+
 
 def _param_schema(p: click.Parameter) -> dict[str, Any] | None:
     """Convert a Click parameter to a JSON Schema property."""
-    if p.name in _SKIP_FLAGS or p.name == "help":
+    if p.name in SKIP_PARAMS or p.name == "help":
         return None
     if isinstance(p, click.Option) and p.hidden:
         return None
@@ -45,6 +52,12 @@ def _param_schema(p: click.Parameter) -> dict[str, Any] | None:
     else:
         prop["type"] = "string"
 
+    multi = (isinstance(p, click.Option) and p.multiple) or (
+        isinstance(p, click.Argument) and p.nargs == -1
+    )
+    if multi:
+        prop = {"type": "array", "items": prop}
+
     if isinstance(p, click.Option) and p.help:
         prop["description"] = p.help
     elif isinstance(p, click.Argument) and p.type.name != "TEXT":
@@ -67,7 +80,15 @@ type ToolIndex = dict[str, "ToolEntry"]
 class ToolEntry:
     """A single tool derived from a Click command."""
 
-    __slots__ = ("name", "description", "schema", "cmd_path", "guarded", "positional")
+    __slots__ = (
+        "name",
+        "description",
+        "schema",
+        "cmd_path",
+        "guarded",
+        "positional",
+        "arg_order",
+    )
 
     def __init__(  # noqa: D107
         self,
@@ -78,6 +99,7 @@ class ToolEntry:
         *,
         guarded: bool = False,
         positional: frozenset[str] = frozenset(),
+        arg_order: tuple[str, ...] = (),
     ) -> None:
         self.name = name
         self.description = description
@@ -85,6 +107,7 @@ class ToolEntry:
         self.cmd_path = cmd_path
         self.guarded = guarded
         self.positional = positional
+        self.arg_order = arg_order
 
 
 def _tool_name(path: list[str]) -> str:
@@ -92,6 +115,54 @@ def _tool_name(path: list[str]) -> str:
     return "_".join(seg.replace("-", "_") for seg in path)
 
 
+def _make_entry(cmd: click.Command, path: list[str]) -> ToolEntry:
+    """Build a ToolEntry (schema, positional order, guard) for one command."""
+    properties: dict[str, Any] = {}
+    required: list[str] = []
+    pos: list[str] = []
+    for p in cmd.params:
+        if p.name is None:
+            continue
+        prop = _param_schema(p)
+        if prop is None:
+            continue
+        pname = p.name.replace("-", "_")
+        properties[pname] = prop
+        if isinstance(p, click.Argument):
+            required.append(pname)
+            pos.append(pname)
+        elif isinstance(p, click.Option) and (p.required or p.prompt):
+            # prompt=True options would hang the MCP subprocess waiting
+            # for TTY input, so force callers to always supply them.
+            required.append(pname)
+
+    guarded = is_guarded(cmd)
+    if guarded:
+        properties["yes"] = dict(_YES_PROP)
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+        "additionalProperties": False,
+    }
+    if required:
+        schema["required"] = required
+
+    desc = (cmd.help or "").split("\n")[0]
+    if guarded:
+        desc += " [guarded: dry-run by default, pass yes=true to apply]"
+
+    return ToolEntry(
+        name=_tool_name(path),
+        description=desc,
+        schema=schema,
+        cmd_path=path,
+        guarded=guarded,
+        positional=frozenset(pos),
+        arg_order=tuple(pos),
+    )
+
+
 def _walk_commands(
     group: click.Group,
     prefix: list[str],
@@ -103,45 +174,8 @@ def _walk_commands(
         if isinstance(cmd, click.Group):
             _walk_commands(cmd, path, index)
             continue
-
-        properties: dict[str, Any] = {}
-        required: list[str] = []
-        pos: set[str] = set()
-        for p in cmd.params:
-            if p.name is None:
-                continue
-            prop = _param_schema(p)
-            if prop is None:
-                continue
-            pname = p.name.replace("-", "_")
-            properties[pname] = prop
-            if isinstance(p, click.Argument):
-                required.append(pname)
-                pos.add(pname)
-            elif isinstance(p, click.Option) and p.required:
-                required.append(pname)
-
-        schema: dict[str, Any] = {
-            "type": "object",
-            "properties": properties,
-        }
-        if required:
-            schema["required"] = required
-
-        guarded = is_guarded(cmd)
-        desc = (cmd.help or "").split("\n")[0]
-        if guarded:
-            desc += " [guarded: dry-run by default, pass yes=true to apply]"
-
-        tool_name = _tool_name(path)
-        index[tool_name] = ToolEntry(
-            name=tool_name,
-            description=desc,
-            schema=schema,
-            cmd_path=path,
-            guarded=guarded,
-            positional=frozenset(pos),
-        )
+        entry = _make_entry(cmd, path)
+        index[entry.name] = entry
 
 
 def build_tool_index(root: click.Group) -> ToolIndex:
@@ -157,42 +191,8 @@ def build_tool_index(root: click.Group) -> ToolIndex:
         if isinstance(cmd, click.Group):
             _walk_commands(cmd, [name], index)
         else:
-            path = [name]
-            properties: dict[str, Any] = {}
-            required: list[str] = []
-            pos: set[str] = set()
-            for p in cmd.params:
-                if p.name is None:
-                    continue
-                prop = _param_schema(p)
-                if prop is None:
-                    continue
-                pname = p.name.replace("-", "_")
-                properties[pname] = prop
-                if isinstance(p, click.Argument):
-                    required.append(pname)
-                    pos.add(pname)
-                elif isinstance(p, click.Option) and p.required:
-                    required.append(pname)
-            schema: dict[str, Any] = {
-                "type": "object",
-                "properties": properties,
-            }
-            if required:
-                schema["required"] = required
-            guarded = is_guarded(cmd)
-            desc = (cmd.help or "").split("\n")[0]
-            if guarded:
-                desc += " [guarded: dry-run by default, pass yes=true to apply]"
-            tool_name = _tool_name(path)
-            index[tool_name] = ToolEntry(
-                name=tool_name,
-                description=desc,
-                schema=schema,
-                cmd_path=path,
-                guarded=guarded,
-                positional=frozenset(pos),
-            )
+            entry = _make_entry(cmd, [name])
+            index[entry.name] = entry
     return index
 
 

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splunkctl
-Version: 0.5.0
+Version: 0.6.0
 Summary: CLI tool for Splunk Enterprise SIEM operations.
 Author: dannyota
 License-Expression: Apache-2.0

{splunkctl-0.5.0 → splunkctl-0.6.0}/splunkctl.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ splunkctl/commands/rules.py
 splunkctl/commands/rules_io.py
 splunkctl/commands/search.py
 splunkctl/commands/server.py
+splunkctl/commands/server_topology.py
 splunkctl/commands/state.py
 splunkctl/commands/state_io.py
 splunkctl/commands/state_io_blobs.py

{splunkctl-0.5.0 → splunkctl-0.6.0}/tests/test_version.py

@@ -4,4 +4,4 @@ from splunkctl import __version__
 
 
 def test_version() -> None:
-    assert __version__ == "0.5.0"
+    assert __version__ == "0.6.0"