dsh-scnet 0.4.2 → 0.5.0

package/skills/scnet-hpc/scripts/scnet_backends/__init__.py

@@ -0,0 +1,53 @@
+"""Backend registry."""
+
+from __future__ import annotations
+
+from .base import BackendContext, BackendError
+from .external import ExternalBackend, discover_external_backends
+from .openapi import OpenAPIBackend
+from .ssh import SSHBackend
+
+
+BUILTINS = {
+    "ssh": SSHBackend,
+    "openapi": OpenAPIBackend,
+}
+
+
+def backend_catalog() -> list[dict[str, object]]:
+    result = [
+        {
+            "name": name,
+            "kind": "builtin",
+            "capabilities": sorted(backend.capabilities),
+        }
+        for name, backend in BUILTINS.items()
+    ]
+    for name, executable in sorted(discover_external_backends().items()):
+        result.append(
+            {
+                "name": name,
+                "kind": "external",
+                "executable": executable,
+                "capabilities": "queried when selected",
+            }
+        )
+    return result
+
+
+def create_backend(name: str, context: BackendContext):
+    if name in BUILTINS:
+        return BUILTINS[name](context)
+    external = discover_external_backends()
+    if name in external:
+        return ExternalBackend(context, name, external[name])
+    available = ", ".join(item["name"] for item in backend_catalog())
+    raise BackendError(f"unknown backend {name!r}; available: {available}")
+
+
+__all__ = [
+    "BackendContext",
+    "BackendError",
+    "backend_catalog",
+    "create_backend",
+]

package/skills/scnet-hpc/scripts/scnet_backends/base.py

@@ -0,0 +1,64 @@
+"""Shared backend interfaces for the SCNet command-line client."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+
+PROTOCOL_VERSION = 1
+
+
+class BackendError(RuntimeError):
+    """A bounded, user-facing backend failure."""
+
+
+@dataclass(frozen=True)
+class BackendContext:
+    repo_root: Path
+    profile_name: str | None
+    profile: Mapping[str, str]
+    timeout: int = 30
+
+
+class Backend:
+    name = "base"
+    capabilities: frozenset[str] = frozenset()
+
+    def __init__(self, context: BackendContext):
+        self.context = context
+
+    def execute(self, operation: str, options: Mapping[str, Any]) -> Any:
+        if operation not in self.capabilities:
+            raise BackendError(
+                f"backend {self.name!r} does not support operation {operation!r}"
+            )
+        handler = getattr(self, f"op_{operation.replace('-', '_')}", None)
+        if handler is None:
+            raise BackendError(
+                f"backend {self.name!r} advertises {operation!r} but has no handler"
+            )
+        return handler(options)
+
+    def preview(self, operation: str, options: Mapping[str, Any]) -> Any:
+        """Describe a mutation without contacting the backend."""
+        if operation not in self.capabilities:
+            raise BackendError(
+                f"backend {self.name!r} does not support operation {operation!r}"
+            )
+        handler = getattr(self, f"preview_{operation.replace('-', '_')}", None)
+        if handler is not None:
+            return handler(options)
+        return {
+            "backend": self.name,
+            "operation": operation,
+            "options": dict(options),
+        }
+
+
+def require_option(options: Mapping[str, Any], name: str) -> Any:
+    value = options.get(name)
+    if value is None or value == "":
+        raise BackendError(f"missing required option: {name}")
+    return value

package/skills/scnet-hpc/scripts/scnet_backends/external.py

@@ -0,0 +1,92 @@
+"""Executable adapter for MCP bridges and other future connectors."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Mapping
+
+from .base import Backend, BackendError, PROTOCOL_VERSION
+
+
+PREFIX = "scnet-hpc-backend-"
+
+
+def discover_external_backends() -> dict[str, str]:
+    found: dict[str, str] = {}
+    search_dirs: list[Path] = []
+    for item in os.environ.get("SCNET_HPC_BACKEND_PATH", "").split(os.pathsep):
+        if item:
+            search_dirs.append(Path(item).expanduser())
+    for directory in search_dirs:
+        if not directory.is_dir():
+            continue
+        for path in directory.glob(f"{PREFIX}*"):
+            if path.is_file() and os.access(path, os.X_OK):
+                found[path.name[len(PREFIX) :]] = str(path)
+    for name in filter(
+        None,
+        (item.strip() for item in os.environ.get(
+            "SCNET_HPC_EXTERNAL_BACKENDS", ""
+        ).split(",")),
+    ):
+        executable = shutil.which(f"{PREFIX}{name}")
+        if executable:
+            found[name] = executable
+    return found
+
+
+class ExternalBackend(Backend):
+    def __init__(self, context, name: str, executable: str):
+        super().__init__(context)
+        self.name = name
+        self.executable = executable
+        self.capabilities = frozenset(self._request("capabilities", {}).get("capabilities", []))
+
+    def _request(self, operation: str, options: Mapping[str, Any]) -> Any:
+        request = {
+            "protocol": "scnet-hpc.backend",
+            "protocol_version": PROTOCOL_VERSION,
+            "operation": operation,
+            "profile_name": self.context.profile_name,
+            "profile": dict(self.context.profile),
+            "options": dict(options),
+        }
+        try:
+            completed = subprocess.run(
+                [self.executable],
+                input=json.dumps(request, ensure_ascii=False),
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=self.context.timeout,
+                check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            raise BackendError(str(exc)) from exc
+        if completed.returncode != 0:
+            raise BackendError(
+                completed.stderr.strip()
+                or f"external backend exited with {completed.returncode}"
+            )
+        try:
+            response = json.loads(completed.stdout)
+        except json.JSONDecodeError as exc:
+            raise BackendError("external backend returned invalid JSON") from exc
+        if not isinstance(response, dict):
+            raise BackendError("external backend response must be a JSON object")
+        if response.get("protocol_version") not in (None, PROTOCOL_VERSION):
+            raise BackendError("external backend protocol version mismatch")
+        if response.get("ok") is False:
+            raise BackendError(str(response.get("error") or "external backend failed"))
+        return response.get("data", response)
+
+    def execute(self, operation: str, options: Mapping[str, Any]) -> Any:
+        if operation not in self.capabilities:
+            raise BackendError(
+                f"backend {self.name!r} does not support operation {operation!r}"
+            )
+        return self._request(operation, options)