msdev 0.9.0__py3-none-any.whl

msdev/core/services/workspace.py

@@ -0,0 +1,567 @@
+"""Workspace registry, remote file, and Git application service."""
+
+from __future__ import annotations
+
+import base64
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any, Sequence
+
+from ..workspace import ResolvedPath, Workspace, normalize_relative
+from ..workspace import client as workspace_client
+from .context import ServiceContext
+
+
+_MAX_READ_BYTES = 16 * 1024 * 1024
+_MAX_RESULTS = 10_000
+_DIGEST_RE = re.compile(r"^[0-9a-fA-F]{64}$")
+_SAFE_GIT_DIFF_OPTIONS = ("--no-textconv", "--no-ext-diff")
+
+
+@dataclass(frozen=True)
+class WorkspaceAddRequest:
+    name: str
+    environment: str
+    root: str
+    execution_root: str | None = None
+    force: bool = False
+
+
+@dataclass(frozen=True)
+class WorkspaceListResult:
+    workspaces: tuple[Workspace, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"workspaces": [asdict(item) for item in self.workspaces]}
+
+
+@dataclass(frozen=True)
+class WorkspaceInspectResult:
+    workspace: Workspace
+    effective_execution_root: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **asdict(self.workspace),
+            "effective_execution_root": self.effective_execution_root,
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceRemoveResult:
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"workspace": self.name, "removed": True}
+
+
+@dataclass(frozen=True)
+class WorkspacePathResult:
+    workspace: str
+    path: str
+    raw: dict[str, Any] = field(repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = dict(self.raw)
+        value["workspace"] = self.workspace
+        return value
+
+
+@dataclass(frozen=True)
+class WorkspaceReadResult:
+    workspace: str
+    path: str
+    content: bytes = field(repr=False)
+    raw: dict[str, Any] = field(repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        try:
+            rendered = self.content.decode("utf-8")
+            encoding = "utf-8"
+        except UnicodeDecodeError:
+            rendered = base64.b64encode(self.content).decode("ascii")
+            encoding = "base64"
+        return {
+            "workspace": self.workspace,
+            "path": self.path,
+            "encoding": encoding,
+            "size": len(self.content),
+            "content": rendered,
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceGlobResult:
+    workspace: str
+    path: str
+    pattern: str
+    matches: tuple[str, ...]
+    raw: dict[str, Any] = field(repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "workspace": self.workspace,
+            "path": self.path,
+            "pattern": self.pattern,
+            "matches": list(self.matches),
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceSearchResult:
+    workspace: str
+    paths: tuple[str, ...]
+    pattern: str
+    matches: tuple[dict[str, Any], ...]
+    raw: dict[str, Any] = field(repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        value: dict[str, Any] = {
+            "workspace": self.workspace,
+            "pattern": self.pattern,
+            "matches": [dict(item) for item in self.matches],
+        }
+        if len(self.paths) == 1:
+            value["path"] = self.paths[0]
+        else:
+            value["paths"] = list(self.paths)
+        return value
+
+
+@dataclass(frozen=True)
+class WorkspaceGitResult:
+    workspace: str
+    returncode: int
+    stdout: str
+    stderr: str
+    stdout_truncated: bool = False
+    stderr_truncated: bool = False
+    output_drain_truncated: bool = False
+    timed_out: bool = False
+    raw: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = dict(self.raw)
+        value["workspace"] = self.workspace
+        return value
+
+
+class WorkspaceService:
+    """Stateless workspace orchestration for the msdev CLI."""
+
+    def __init__(self, context: ServiceContext):
+        self.context = context
+
+    @staticmethod
+    def _required(value: Any, label: str) -> str:
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"{label} must be a non-empty string")
+        if "\0" in value:
+            raise ValueError(f"{label} must not contain NUL")
+        return value
+
+    @staticmethod
+    def _text(value: Any, label: str) -> str:
+        if not isinstance(value, str):
+            raise ValueError(f"{label} must be a string")
+        if "\0" in value:
+            raise ValueError(f"{label} must not contain NUL")
+        return value
+
+    @staticmethod
+    def _boolean(value: Any, label: str) -> bool:
+        if type(value) is not bool:
+            raise ValueError(f"{label} must be a boolean")
+        return value
+
+    @staticmethod
+    def _limit(value: Any, label: str, maximum: int) -> int:
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise ValueError(f"{label} must be an integer")
+        if not 1 <= value <= maximum:
+            raise ValueError(f"{label} must be between 1 and {maximum}")
+        return value
+
+    @staticmethod
+    def _object(value: Any, operation: str) -> dict[str, Any]:
+        if not isinstance(value, dict):
+            raise RuntimeError(f"{operation} returned a non-object result")
+        return dict(value)
+
+    def _workspace(self, name: Any) -> Workspace:
+        return self.context.workspace_store.get(
+            self._required(name, "workspace name")
+        )
+
+    def _resolved(self, name: Any, path: Any = ".") -> ResolvedPath:
+        workspace = self._workspace(name)
+        return ResolvedPath(
+            workspace=workspace,
+            relative=normalize_relative(path),
+        )
+
+    def _create_transport(self, workspace: Workspace) -> Any:
+        return self.context.transport_for_environment(workspace.environment)
+
+    def add(self, request: WorkspaceAddRequest) -> Workspace:
+        if not isinstance(request, WorkspaceAddRequest):
+            raise TypeError("workspace add request must be WorkspaceAddRequest")
+        force = self._boolean(request.force, "force")
+        environment = self._required(
+            request.environment,
+            "workspace environment",
+        )
+        self.context.environment_store.get(environment)
+        workspace = Workspace(
+            name=self._required(request.name, "workspace name"),
+            environment=environment,
+            root=self._required(request.root, "workspace root"),
+            execution_root=request.execution_root,
+        )
+        self.context.workspace_store.add(workspace, force=force)
+        return workspace
+
+    def list(self) -> WorkspaceListResult:
+        return WorkspaceListResult(tuple(self.context.workspace_store.list()))
+
+    def inspect(self, name: Any) -> WorkspaceInspectResult:
+        workspace = self._workspace(name)
+        return WorkspaceInspectResult(
+            workspace,
+            workspace.execution_root or workspace.root,
+        )
+
+    def remove(self, name: Any) -> WorkspaceRemoveResult:
+        workspace_name = self._required(name, "workspace name")
+        self.context.workspace_store.remove(workspace_name)
+        return WorkspaceRemoveResult(workspace_name)
+
+    def stat(self, name: Any, path: Any = ".") -> WorkspacePathResult:
+        resolved = self._resolved(name, path)
+        raw = self._object(
+            workspace_client.stat_path(
+                resolved,
+                create_transport=self._create_transport,
+            ),
+            "workspace.stat",
+        )
+        return WorkspacePathResult(
+            resolved.workspace.name,
+            resolved.relative,
+            raw,
+        )
+
+    def read(
+        self,
+        name: Any,
+        path: Any,
+        *,
+        max_bytes: Any = 1024 * 1024,
+    ) -> WorkspaceReadResult:
+        resolved = self._resolved(name, path)
+        limit = self._limit(max_bytes, "max_bytes", _MAX_READ_BYTES)
+        content, raw = workspace_client.read_file(
+            resolved,
+            max_bytes=limit,
+            create_transport=self._create_transport,
+        )
+        return WorkspaceReadResult(
+            resolved.workspace.name,
+            resolved.relative,
+            content,
+            raw,
+        )
+
+    def list_directory(
+        self,
+        name: Any,
+        path: Any = ".",
+    ) -> WorkspacePathResult:
+        resolved = self._resolved(name, path)
+        raw = self._object(
+            workspace_client.list_directory(
+                resolved,
+                create_transport=self._create_transport,
+            ),
+            "workspace.list",
+        )
+        return WorkspacePathResult(
+            resolved.workspace.name,
+            resolved.relative,
+            raw,
+        )
+
+    def glob(
+        self,
+        name: Any,
+        pattern: Any,
+        *,
+        path: Any = ".",
+        max_results: Any = 1000,
+    ) -> WorkspaceGlobResult:
+        resolved = self._resolved(name, path)
+        requested_pattern = self._text(pattern, "glob pattern")
+        limit = self._limit(max_results, "max_results", _MAX_RESULTS)
+        raw = self._object(
+            workspace_client.glob_result(
+                resolved,
+                requested_pattern,
+                max_results=limit,
+                create_transport=self._create_transport,
+            ),
+            "workspace.glob",
+        )
+        raw_matches = raw.get("matches")
+        if not isinstance(raw_matches, list):
+            raise ValueError("workspace.glob returned invalid matches")
+        matches: list[str] = []
+        for item in raw_matches:
+            if not isinstance(item, dict) or not isinstance(item.get("path"), str):
+                raise ValueError("workspace.glob returned an invalid match")
+            matches.append(item["path"])
+        return WorkspaceGlobResult(
+            resolved.workspace.name,
+            resolved.relative,
+            requested_pattern,
+            tuple(matches),
+            raw,
+        )
+
+    def search(
+        self,
+        name: Any,
+        pattern: Any,
+        *,
+        paths: Sequence[str] = (".",),
+        glob: str | None = None,
+        max_results: Any = 1000,
+    ) -> WorkspaceSearchResult:
+        workspace = self._workspace(name)
+        search_pattern = self._text(pattern, "search pattern")
+        if (
+            isinstance(paths, (str, bytes))
+            or not isinstance(paths, (list, tuple))
+            or not paths
+            or not all(isinstance(item, str) for item in paths)
+        ):
+            raise ValueError("search paths must be a non-empty string array")
+        normalized_paths = tuple(normalize_relative(item) for item in paths)
+        glob_filter = normalize_relative(glob) if glob is not None else None
+        limit = self._limit(max_results, "max_results", _MAX_RESULTS)
+        raw = self._object(
+            workspace_client.search_workspace(
+                workspace,
+                search_pattern,
+                paths=normalized_paths,
+                glob=glob_filter,
+                max_results=limit,
+                create_transport=self._create_transport,
+            ),
+            "workspace.search",
+        )
+        raw_matches = raw.get("matches")
+        if not isinstance(raw_matches, list) or not all(
+            isinstance(item, dict) for item in raw_matches
+        ):
+            raise ValueError("workspace.search returned invalid matches")
+        return WorkspaceSearchResult(
+            workspace.name,
+            normalized_paths,
+            search_pattern,
+            tuple(dict(item) for item in raw_matches),
+            raw,
+        )
+
+    @staticmethod
+    def _content(value: Any) -> bytes:
+        if not isinstance(value, bytes):
+            raise TypeError("workspace content must be bytes")
+        return value
+
+    @staticmethod
+    def _digest(value: Any, *, required: bool) -> str | None:
+        if value is None and not required:
+            return None
+        if not isinstance(value, str) or not _DIGEST_RE.fullmatch(value):
+            raise ValueError(
+                "expected_sha256 must be a 64-character hexadecimal digest"
+            )
+        return value.lower()
+
+    def _write(
+        self,
+        name: Any,
+        path: Any,
+        content: Any,
+        *,
+        expected_sha256: Any,
+        digest_required: bool,
+    ) -> WorkspacePathResult:
+        resolved = self._resolved(name, path)
+        payload = self._content(content)
+        digest = self._digest(expected_sha256, required=digest_required)
+        raw = self._object(
+            workspace_client.write_bytes(
+                resolved,
+                payload,
+                expected_sha256=digest,
+                create_transport=self._create_transport,
+            ),
+            "workspace.write",
+        )
+        return WorkspacePathResult(
+            resolved.workspace.name,
+            resolved.relative,
+            raw,
+        )
+
+    def write(
+        self,
+        name: Any,
+        path: Any,
+        content: Any,
+        *,
+        expected_sha256: Any = None,
+    ) -> WorkspacePathResult:
+        return self._write(
+            name,
+            path,
+            content,
+            expected_sha256=expected_sha256,
+            digest_required=False,
+        )
+
+    def apply_patch(
+        self,
+        name: Any,
+        path: Any,
+        content: Any,
+        *,
+        expected_sha256: Any,
+    ) -> WorkspacePathResult:
+        return self._write(
+            name,
+            path,
+            content,
+            expected_sha256=expected_sha256,
+            digest_required=True,
+        )
+
+    def delete(self, name: Any, path: Any) -> WorkspacePathResult:
+        resolved = self._resolved(name, path)
+        raw = self._object(
+            workspace_client.delete_path(
+                resolved,
+                create_transport=self._create_transport,
+            ),
+            "workspace.delete",
+        )
+        return WorkspacePathResult(
+            resolved.workspace.name,
+            resolved.relative,
+            raw,
+        )
+
+    @staticmethod
+    def _result_boolean(raw: dict[str, Any], key: str) -> bool:
+        value = raw.get(key, False)
+        if type(value) is not bool:
+            raise RuntimeError(f"workspace Git result {key} must be a boolean")
+        return value
+
+    def _git_result(
+        self,
+        name: Any,
+        operation: str,
+        argv: tuple[str, ...] = (),
+    ) -> WorkspaceGitResult:
+        workspace = self._workspace(name)
+        raw = self._object(
+            workspace_client.git_workspace(
+                workspace,
+                operation,
+                argv,
+                execution_root=workspace.execution_root or workspace.root,
+                create_transport=self._create_transport,
+            ),
+            f"workspace.git-{operation}",
+        )
+        returncode = raw.get("returncode")
+        if isinstance(returncode, bool) or not isinstance(returncode, int):
+            raise RuntimeError("workspace Git result is missing integer returncode")
+        stdout = raw.get("stdout", "")
+        stderr = raw.get("stderr", "")
+        if not isinstance(stdout, str) or not isinstance(stderr, str):
+            raise RuntimeError("workspace Git stdout and stderr must be strings")
+        return WorkspaceGitResult(
+            workspace=workspace.name,
+            returncode=returncode,
+            stdout=stdout,
+            stderr=stderr,
+            stdout_truncated=self._result_boolean(raw, "stdout_truncated"),
+            stderr_truncated=self._result_boolean(raw, "stderr_truncated"),
+            output_drain_truncated=self._result_boolean(
+                raw,
+                "output_drain_truncated",
+            ),
+            timed_out=self._result_boolean(raw, "timed_out"),
+            raw=raw,
+        )
+
+    def git_status(self, name: Any) -> WorkspaceGitResult:
+        return self._git_result(name, "status")
+
+    def git_diff(
+        self,
+        name: Any,
+        argv: Sequence[str] = (),
+    ) -> WorkspaceGitResult:
+        extra = self._git_diff_arguments(argv)
+        if extra[:1] == ("--",):
+            extra = extra[1:]
+        self._validate_safe_git_diff_arguments(extra)
+        return self._run_git_diff(name, extra)
+
+    @staticmethod
+    def _git_diff_arguments(argv: Any) -> tuple[str, ...]:
+        if (
+            isinstance(argv, (str, bytes))
+            or not isinstance(argv, (list, tuple))
+            or not all(isinstance(item, str) for item in argv)
+        ):
+            raise ValueError("git diff arguments must be a string array")
+        return tuple(argv)
+
+    @staticmethod
+    def _validate_safe_git_diff_arguments(argv: tuple[str, ...]) -> None:
+        prohibited = (
+            "--output",
+            "--ext-diff",
+            "--textconv",
+            "--no-index",
+        )
+        for argument in argv:
+            if argument == "--":
+                return
+            if argument == "-o" or argument.startswith("-o"):
+                raise ValueError(
+                    f"git diff argument is not allowed: {argument}"
+                )
+            if any(
+                argument == option or argument.startswith(f"{option}=")
+                for option in prohibited
+            ):
+                raise ValueError(
+                    f"git diff argument is not allowed: {argument}"
+                )
+
+    def _run_git_diff(
+        self,
+        name: Any,
+        extra: tuple[str, ...],
+    ) -> WorkspaceGitResult:
+        return self._git_result(
+            name,
+            "diff",
+            (*_SAFE_GIT_DIFF_OPTIONS, *extra),
+        )