@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/mwi/code/engine/motionworks_iec_mcp/snapshot.py

@@ -0,0 +1,138 @@
+"""SHA-256 tree snapshots, used as the safety spine around every write.
+
+A snapshot is a JSON manifest of relative path -> SHA-256 for every file in a
+project.  Taking one before a change and verifying after gives a precise answer
+to "what exactly did this touch?", which matters because MotionWorks will
+rewrite unrelated state on the next save.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+from .errors import VerificationFailed
+
+MANIFEST_FORMAT = "motionworks-sha256-v1"
+
+#: Directory names never included in a snapshot; they are build output.
+_SKIP_DIRS = {"__pycache__", ".git"}
+
+
+def sha256_file(path: Path, chunk: int = 1 << 20) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(chunk), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def hash_tree(
+    base: Path,
+    exclude: Path | None = None,
+    include_generated: bool = True,
+) -> dict[str, str]:
+    """Hash every file under ``base``, keyed by POSIX-style relative path.
+
+    ``tmp.sto`` build caches are included by default because a change there is
+    still a change worth seeing, but ``include_generated=False`` filters them
+    out when only source differences matter.
+    """
+    base = base.resolve()
+    exclude_resolved = exclude.resolve() if exclude else None
+    files: dict[str, str] = {}
+    for path in sorted(base.rglob("*")):
+        if not path.is_file():
+            continue
+        if any(part in _SKIP_DIRS for part in path.parts):
+            continue
+        if exclude_resolved is not None and path.resolve() == exclude_resolved:
+            continue
+        if not include_generated and path.suffix.lower() in {".sto", ".sn"}:
+            continue
+        files[path.relative_to(base).as_posix()] = sha256_file(path)
+    return files
+
+
+def make_manifest(
+    base: Path,
+    exclude: Path | None = None,
+    include_generated: bool = True,
+    note: str | None = None,
+) -> dict[str, object]:
+    return {
+        "format": MANIFEST_FORMAT,
+        "base": str(Path(base).resolve()),
+        "created": datetime.now().isoformat(timespec="seconds"),
+        "note": note,
+        "files": hash_tree(base, exclude, include_generated),
+    }
+
+
+def write_manifest(manifest: dict[str, object], output: Path) -> Path:
+    output = Path(output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    return output
+
+
+def load_manifest(path: Path) -> dict[str, object]:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if data.get("format") != MANIFEST_FORMAT:
+        raise VerificationFailed(
+            f"Unsupported manifest format {data.get('format')!r}; "
+            f"expected {MANIFEST_FORMAT!r}"
+        )
+    return data
+
+
+def diff_manifest(
+    manifest: dict[str, object],
+    base: Path | None = None,
+    include_generated: bool = True,
+) -> dict[str, list[str]]:
+    """Compare a manifest against the current tree.
+
+    Returns lists of ``missing``, ``added``, and ``changed`` paths.  An empty
+    result across all three means the tree is byte-for-byte identical.
+    """
+    target = Path(base) if base else Path(str(manifest["base"]))
+    expected: dict[str, str] = manifest["files"]  # type: ignore[assignment]
+    actual = hash_tree(target, include_generated=include_generated)
+    return {
+        "missing": sorted(set(expected) - set(actual)),
+        "added": sorted(set(actual) - set(expected)),
+        "changed": sorted(
+            name for name in set(actual) & set(expected) if actual[name] != expected[name]
+        ),
+    }
+
+
+def verify(
+    manifest: dict[str, object],
+    base: Path | None = None,
+    include_generated: bool = True,
+    raise_on_difference: bool = True,
+) -> dict[str, list[str]]:
+    result = diff_manifest(manifest, base, include_generated)
+    if raise_on_difference and any(result.values()):
+        summary = ", ".join(f"{k}={len(v)}" for k, v in result.items() if v)
+        raise VerificationFailed(f"Snapshot verification failed: {summary}")
+    return result
+
+
+def default_backup_dir(project_root: Path) -> Path:
+    """Where to place backups for a project.
+
+    Deliberately outside the project directory: a backup inside the tree would
+    be picked up by MotionWorks and by later snapshots.
+    """
+    from .staging import workspace_root, StagingRefused
+    workspace = workspace_root()
+    base = Path(os.environ.get("MOTIONWORKS_MCP_BACKUP_DIR", workspace / '.motionworks')).resolve()
+    if not base.is_relative_to(workspace):
+        raise StagingRefused('REFUSED: backup directory must remain inside the workspace')
+    return base / 'backups' / project_root.name

package/vendor/mwi/code/engine/motionworks_iec_mcp/st_comments.py

@@ -0,0 +1,25 @@
+"""Resolve native ST comment references using the worksheet translation file."""
+import re
+import xml.etree.ElementTree as ET
+
+MARKER = re.compile(r'\x07(\d+),(\d+)\x07')
+
+def resolve_comments(body, translation_path):
+    if '\x07' not in body:
+        return body
+    root = ET.parse(translation_path).getroot()
+    comments = {}
+    for item in root.findall('./ItemList/item'):
+        values = [t for t in item.findall('translation')
+                  if t.get('{http://www.w3.org/XML/1998/namespace}lang') == 'undefined']
+        if len(values) != 1 or item.get('id') in comments:
+            raise ValueError('Ambiguous native comment translation')
+        comments[item.get('id')] = ''.join(values[0].itertext())
+    def replace(match):
+        if match[1] != '1' or match[2] not in comments:
+            raise ValueError('Unresolved native ST comment reference')
+        return comments[match[2]]
+    result = MARKER.sub(replace, body)
+    if '\x07' in result:
+        raise ValueError('Unsupported native ST comment reference')
+    return result

package/vendor/mwi/code/engine/motionworks_iec_mcp/staging.py

@@ -0,0 +1,179 @@
+"""Workspace-scoped project guards shared by the file engine.
+
+The host supplies the current session workspace for each child process. Missing scope
+fails closed. Staged copies live at <workspace>/.motionworks/stage and identities
+must match that workspace, source, wrapper and project directory.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .errors import MotionWorksError
+
+#: Optional consistency check; it cannot relocate the workspace stage.
+STAGE_ENV = "MOTIONWORKS_MCP_STAGE"
+
+
+class StagingRefused(MotionWorksError):
+    """A project path outside the staging root."""
+
+
+def workspace_root() -> Path:
+    value = os.environ.get("MOTIONWORKS_MCP_WORKSPACE")
+    if not value or not Path(value).is_absolute():
+        raise StagingRefused("REFUSED: no absolute session workspace was supplied to the engine.")
+    return Path(value).resolve()
+
+
+def staging_root() -> Path:
+    """A private stage within the calling workspace, never the shared plugin stage."""
+    workspace = workspace_root()
+    fixed = workspace / ".motionworks" / "stage"
+    if not _inside(fixed, workspace):
+        raise StagingRefused("REFUSED: workspace stage resolves outside the workspace.")
+    override = os.environ.get(STAGE_ENV)
+    if override and Path(override).resolve() != fixed.resolve():
+        raise StagingRefused("REFUSED: stage override does not match the calling workspace stage.")
+    return fixed.resolve()
+
+
+def _inside(child: Path, parent: Path) -> bool:
+    try:
+        child.resolve().relative_to(parent.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def assert_staged(project_root: Path | str, what: str = "project") -> Path:
+    """Return the resolved project root, or refuse if it is not a staged copy.
+
+    Called by every write and every IDE open. The message names the path, the staging root and the
+    way through - because the caller is usually an agent that has just been stopped mid-task and
+    needs to know what to do instead, not merely that it may not.
+    """
+    given = Path(project_root).resolve()
+    root = staging_root()
+
+    if given == root or _inside(given, root):
+        return given
+
+    raise StagingRefused(
+        f"REFUSED: {what} '{given}' is outside the staging root '{root}'. This engine only ever "
+        f"reads or writes a STAGED COPY, never a real project tree - a real tree holds the owner's "
+        f"work and MotionWorks rewrites whole files, so a mistake there is not recoverable from "
+        f"here. Stage a copy first with mw_ide_stage, then point at the copy. "
+        f"{STAGE_ENV} cannot aim this root at a real project."
+    )
+
+
+def assert_proven(project_root: Path | str) -> Path:
+    """Refuse a staged copy that mw_ide_stage did not record a source for.
+
+    A directory under stage/ is not provenance. Scripts that call this engine directly
+    used to edit whichever copy was there, including one with no recorded workspace source.
+    """
+    import json
+
+    given = assert_staged(project_root)
+    root = staging_root()
+    path = given
+    if path.suffix.lower() == ".mwt":
+        path = path.with_suffix("")
+    try:
+        rel = path.resolve().relative_to(root.resolve())
+    except ValueError as exc:
+        raise StagingRefused(
+            f"REFUSED: '{given}' is not inside the staging root '{root}'."
+        ) from exc
+    if not rel.parts:
+        raise StagingRefused(
+            f"REFUSED: '{given}' is the staging root, not a project."
+        )
+    name = rel.parts[0]
+    ident = root / f"{name}.identity.json"
+    if not ident.is_file():
+        raise StagingRefused(
+            f"REFUSED: staged project '{name}' has no identity file. Stage it from the workspace "
+            f"with mw_ide_stage. A folder copied into stage by hand is not edited."
+        )
+    try:
+        data = json.loads(ident.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise StagingRefused(f"REFUSED: could not read {ident.name}: {exc}") from exc
+    if not data.get("source"):
+        raise StagingRefused(
+            f"REFUSED: staged project '{name}' has no recorded source. Stage it again from the "
+            f"workspace project. A copy with no provenance is not edited."
+        )
+    workspace = workspace_root()
+    if (not data.get("workspace")
+            or Path(data["workspace"]).resolve() != workspace
+            or not _inside(Path(data["source"]), workspace)
+            or not _inside(Path(data.get("source_directory", data["source"])), workspace)
+            or Path(data.get("staged_directory", "")).resolve() != (root / name).resolve()
+            or Path(data.get("staged_mwt", "")).resolve() != (root / f"{name}.mwt").resolve()):
+        raise StagingRefused("REFUSED: project identity does not belong to the calling workspace.")
+    project = root / name
+    if project.is_dir():
+        for member in project.rglob("*"):
+            if not _inside(member, project):
+                raise StagingRefused(f"REFUSED: linked project member escapes the project: {member}")
+    return given
+
+
+def assert_direct_attached(project_root: Path | str) -> Path:
+    """Authorize read-only inspection of one backed-up, directly attached workspace project.
+
+    Offline writers still call assert_proven/assert_staged and remain stage-only.
+    """
+    import hashlib
+    import json
+
+    given = Path(project_root).resolve()
+    directory = given.with_suffix("") if given.suffix.lower() == ".mwt" else given
+    wrapper = Path(str(directory) + ".mwt")
+    workspace = workspace_root()
+    if not _inside(directory, workspace) or _inside(directory, workspace / ".motionworks"):
+        raise StagingRefused("REFUSED: direct project is outside the writable workspace area.")
+    records = workspace / ".motionworks" / "attached" / "records"
+    if not records.is_dir():
+        raise StagingRefused("REFUSED: direct project has no verified attachment backup.")
+    for record_file in records.glob("*.json"):
+        try:
+            record = json.loads(record_file.read_text(encoding="utf-8"))
+            if record.get("mode") != "direct":
+                continue
+            if Path(record["mwt"]).resolve() != wrapper or Path(record["directory"]).resolve() != directory:
+                continue
+            backup = Path(record["backup"]).resolve()
+            manifest = Path(record["backup_manifest"]).resolve()
+            backup_root = workspace / ".motionworks" / "attached" / "backups"
+            if (Path(record["workspace"]).resolve() != workspace
+                    or not _inside(backup, backup_root)
+                    or not _inside(manifest, backup)
+                    or not manifest.is_file()
+                    or hashlib.sha256(manifest.read_bytes()).hexdigest() != record["backup_manifest_sha256"]
+                    or not wrapper.is_file() or not directory.is_dir()):
+                break
+            manifest_data = json.loads(manifest.read_text(encoding="utf-8"))
+            if not isinstance(manifest_data.get("files"), list) or any(
+                    not _inside(backup / item["path"], backup)
+                    or not (backup / item["path"]).is_file()
+                    for item in manifest_data["files"]):
+                break
+            for member in directory.rglob("*"):
+                if not _inside(member, directory):
+                    raise StagingRefused(f"REFUSED: linked project member escapes attachment: {member}")
+            return given
+        except (OSError, ValueError, KeyError, TypeError):
+            continue
+    raise StagingRefused("REFUSED: direct project attachment or backup identity is invalid.")
+
+
+def is_staged(project_root: Path | str) -> bool:
+    """Whether a path is inside the staging root, for a caller that wants to ask rather than try."""
+    given = Path(project_root).resolve()
+    root = staging_root()
+    return given == root or _inside(given, root)