Add MCP spec server and preflight validation

Author: ishandhanani

pyproject.toml

@@ -13,6 +13,7 @@ dependencies = [
     "jinja2>=3.1.0",
     "marshmallow>=3.20.0",
     "marshmallow-dataclass>=8.6.0",
+    "mcp>=1.27.0",
     "pydantic>=2.5.0",
     "requests>=2.31.0",
     "rich>=13.0.0",
@@ -25,6 +26,7 @@ srtctl = "srtctl.cli.submit:main"
 srtctl-i = "srtctl.cli.interactive:main"
 srtctl-sweep = "srtctl.cli.do_sweep:main"
 srtctl-setup-head = "srtctl.cli.setup_head:main"
+srtctl-mcp = "srtctl.mcp.server:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/srtctl"]

src/srtctl/cli/submit.py

@@ -52,6 +52,7 @@
 from srtctl.core.lockfile import load_lockfile_fingerprints
 from srtctl.core.schema import SrtConfig
 from srtctl.core.status import create_job_record
+from srtctl.core.validation import preflight_config_variants
 
 console = Console()
 logger = logging.getLogger(__name__)
@@ -65,6 +66,24 @@ def _record_submission(data: dict) -> None:
     _submissions.append(data)
 
 
+def _format_preflight_error(label: str, results: list[Any]) -> str:
+    lines = [f"Preflight failed for {label}:"]
+    for result in results:
+        for issue in result.errors:
+            lines.append(f"- {issue.field}: {issue.message}")
+    return "\n".join(lines)
+
+
+def _assert_preflight_passed(raw_config: dict[str, Any], *, label: str) -> None:
+    results = preflight_config_variants(
+        raw_config,
+        cluster_config=load_cluster_config(),
+    )
+    failed = [result for result in results if not result.ok]
+    if failed:
+        raise ValueError(_format_preflight_error(label, failed))
+
+
 def _install_mock_submit_patches() -> list:
     """Stub the subset of `submit_with_orchestrator` that reaches real infra.
 
@@ -677,6 +696,16 @@ def submit_single(
     if config is None:
         raise ValueError("Either config_path or config must be provided")
 
+    if runtime_config_text is not None:
+        raw_config = yaml.safe_load(runtime_config_text)
+    elif config_path is not None:
+        with open(config_path) as f:
+            raw_config = yaml.safe_load(f)
+    else:
+        raw_config = config.model_dump(mode="json")
+
+    _assert_preflight_passed(raw_config, label=str(config_path or "<inline-config>"))
+
     # Always use orchestrator mode
     return submit_with_orchestrator(
         config_path=config_path or Path("./config.yaml"),
@@ -1091,6 +1120,7 @@ def main():
   srtctl apply -f config.yaml                    # Submit job
   srtctl apply -f ./configs/                     # Submit all YAMLs in directory
   srtctl apply -f config.yaml --sweep            # Submit sweep
+  srtctl preflight -f config.yaml                # Check model/container availability
   srtctl dry-run -f config.yaml                  # Dry run
   srtctl resolve-override -f config.yaml         # Resolve override YAML (no submit)
   srtctl resolve-override -f config.yaml --stdout  # Print to stdout
@@ -1144,6 +1174,19 @@ def add_common_args(p):
     dry_run_parser = subparsers.add_parser("dry-run", help="Validate without submitting")
     add_common_args(dry_run_parser)
 
+    preflight_parser = subparsers.add_parser(
+        "preflight",
+        help="Check model and container availability without submitting",
+    )
+    preflight_parser.add_argument(
+        "-f",
+        "--file",
+        type=str,
+        required=True,
+        dest="config",
+        help="YAML config file, or file:selector for overrides",
+    )
+
     resolve_parser = subparsers.add_parser(
         "resolve-override",
         help="Resolve override YAML into specialised files without submitting",
@@ -1266,6 +1309,30 @@ def add_common_args(p):
             resolve_override_cmd(config_path, selector=selector, stdout=getattr(args, "stdout", False))
             return
 
+        if args.command == "preflight":
+            if config_path.is_dir():
+                raise ValueError("preflight currently expects a file, not a directory")
+            with open(config_path) as f:
+                raw_config = yaml.safe_load(f)
+            results = preflight_config_variants(
+                raw_config,
+                cluster_config=load_cluster_config(),
+                selector=selector,
+            )
+            for result in results:
+                icon = "[green]✓[/]" if result.ok else "[red]✗[/]"
+                console.print(f"{icon} {result.variant}")
+                console.print(f"  model.path: {result.model.message}")
+                console.print(f"  model.container: {result.container.message}")
+            if any(not result.ok for result in results):
+                raise ValueError(
+                    _format_preflight_error(
+                        str(config_path),
+                        [result for result in results if not result.ok],
+                    )
+                )
+            return
+
         setup_script = getattr(args, "setup_script", None)
         output_dir = getattr(args, "output_dir", None)
 

src/srtctl/core/validation.py

@@ -12,13 +12,20 @@
 from __future__ import annotations
 
 import logging
+import os
 import threading
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import requests
 
+from srtctl.core.config import (
+    generate_override_configs,
+    load_cluster_config,
+    resolve_config_with_defaults,
+)
+
 if TYPE_CHECKING:
     from srtctl.core.schema import SrtConfig
 
@@ -36,6 +43,228 @@ class ValidationResult:
     message: str
 
 
+@dataclass(frozen=True)
+class PreflightIssue:
+    code: str
+    field: str
+    message: str
+
+
+@dataclass(frozen=True)
+class PreflightResolution:
+    field: str
+    raw: str | None
+    resolved: str | None
+    source: str
+    ok: bool
+    message: str
+
+
+@dataclass(frozen=True)
+class PreflightResult:
+    variant: str
+    ok: bool
+    model: PreflightResolution
+    container: PreflightResolution
+    errors: list[PreflightIssue]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "variant": self.variant,
+            "ok": self.ok,
+            "model": self.model.__dict__,
+            "container": self.container.__dict__,
+            "errors": [issue.__dict__ for issue in self.errors],
+        }
+
+
+def _expand_path(value: str) -> str:
+    return os.path.expanduser(os.path.expandvars(value))
+
+
+def _check_path(path_str: str, *, expect: str) -> tuple[bool, str]:
+    path = Path(path_str).resolve()
+    if not path.exists():
+        return False, f"not found: {path}"
+    if expect == "dir" and not path.is_dir():
+        return False, f"not a directory: {path}"
+    if expect == "file" and not path.is_file():
+        return False, f"not a file: {path}"
+    return True, f"exists: {path}"
+
+
+def _preflight_model(
+    raw_config: dict[str, Any],
+    resolved_config: dict[str, Any],
+    cluster_config: dict[str, Any] | None,
+) -> tuple[PreflightResolution, list[PreflightIssue]]:
+    raw = raw_config.get("model", {}).get("path")
+    resolved = resolved_config.get("model", {}).get("path")
+    aliases = (cluster_config or {}).get("model_paths") or {}
+    source = "srtslurm.yaml:model_paths" if raw in aliases else "literal"
+
+    if not raw or not resolved:
+        issue = PreflightIssue(
+            code="model-missing",
+            field="model.path",
+            message="model.path is required",
+        )
+        return (
+            PreflightResolution(
+                field="model.path",
+                raw=raw,
+                resolved=resolved,
+                source=source,
+                ok=False,
+                message=issue.message,
+            ),
+            [issue],
+        )
+
+    ok, detail = _check_path(_expand_path(resolved), expect="dir")
+    if ok:
+        return (
+            PreflightResolution(
+                field="model.path",
+                raw=raw,
+                resolved=str(Path(_expand_path(resolved)).resolve()),
+                source=source,
+                ok=True,
+                message=detail,
+            ),
+            [],
+        )
+
+    if source == "srtslurm.yaml:model_paths":
+        message = (
+            f"Model alias '{raw}' resolved to '{resolved}', but that path is unavailable. "
+            "Pull or register the model yourself before submitting."
+        )
+    else:
+        message = (
+            f"Model '{raw}' is not a local model path and is not defined in srtslurm.yaml "
+            "model_paths. Pull or register the model yourself before submitting."
+        )
+    issue = PreflightIssue(
+        code="model-not-available",
+        field="model.path",
+        message=message,
+    )
+    return (
+        PreflightResolution(
+            field="model.path",
+            raw=raw,
+            resolved=resolved,
+            source=source,
+            ok=False,
+            message=message,
+        ),
+        [issue],
+    )
+
+
+def _preflight_container(
+    raw_config: dict[str, Any],
+    resolved_config: dict[str, Any],
+    cluster_config: dict[str, Any] | None,
+) -> tuple[PreflightResolution, list[PreflightIssue]]:
+    raw = raw_config.get("model", {}).get("container")
+    resolved = resolved_config.get("model", {}).get("container")
+    aliases = (cluster_config or {}).get("containers") or {}
+    source = "srtslurm.yaml:containers" if raw in aliases else "literal"
+
+    if not raw or not resolved:
+        issue = PreflightIssue(
+            code="container-missing",
+            field="model.container",
+            message="model.container is required",
+        )
+        return (
+            PreflightResolution(
+                field="model.container",
+                raw=raw,
+                resolved=resolved,
+                source=source,
+                ok=False,
+                message=issue.message,
+            ),
+            [issue],
+        )
+
+    ok, detail = _check_path(_expand_path(resolved), expect="file")
+    if ok:
+        return (
+            PreflightResolution(
+                field="model.container",
+                raw=raw,
+                resolved=str(Path(_expand_path(resolved)).resolve()),
+                source=source,
+                ok=True,
+                message=detail,
+            ),
+            [],
+        )
+
+    if source == "srtslurm.yaml:containers":
+        message = (
+            f"Container alias '{raw}' resolved to '{resolved}', but that file is unavailable. "
+            "Provide or register the container yourself before submitting."
+        )
+    else:
+        message = (
+            f"Container '{raw}' is not a local container path and is not defined in "
+            "srtslurm.yaml containers. Provide or register the container yourself before submitting."
+        )
+    issue = PreflightIssue(
+        code="container-not-available",
+        field="model.container",
+        message=message,
+    )
+    return (
+        PreflightResolution(
+            field="model.container",
+            raw=raw,
+            resolved=resolved,
+            source=source,
+            ok=False,
+            message=message,
+        ),
+        [issue],
+    )
+
+
+def preflight_config_variants(
+    raw_config: dict[str, Any],
+    *,
+    cluster_config: dict[str, Any] | None = None,
+    selector: str | None = None,
+) -> list[PreflightResult]:
+    active_cluster_config = load_cluster_config() if cluster_config is None else cluster_config
+    variants = (
+        generate_override_configs(raw_config, selector=selector)
+        if "base" in raw_config
+        else [("base", raw_config)]
+    )
+    results: list[PreflightResult] = []
+    for suffix, variant in variants:
+        resolved = resolve_config_with_defaults(variant, active_cluster_config)
+        model, model_issues = _preflight_model(variant, resolved, active_cluster_config)
+        container, container_issues = _preflight_container(
+            variant, resolved, active_cluster_config
+        )
+        issues = [*model_issues, *container_issues]
+        results.append(
+            PreflightResult(
+                variant=suffix,
+                ok=not issues,
+                model=model,
+                container=container,
+                errors=issues,
+            )
+        )
+    return results
+
+
 def validate_local_path(name: str, path: str) -> ValidationResult:
     """Check that a local file or directory exists."""
     try:

src/srtctl/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP surface for srtctl."""