engineering-platform 2.3.96__tar.gz → 2.3.97__tar.gz

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-platform
-Version: 2.3.96
+Version: 2.3.97
 Summary: Local-first Engineering Platform execution operations runtime
 Author: Peter van Tol
 License: MIT

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.96"
+version = "2.3.97"
 description = "Local-first Engineering Platform execution operations runtime"
 readme = "README.md"
 requires-python = ">=3.14,<3.15"

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform/ENGINEERING_PLATFORM_CONFIG.json

@@ -3,7 +3,7 @@
   "platform": {
     "id": "engineering-platform",
     "name": "Engineering Platform",
-    "version": "2.3.96",
+    "version": "2.3.97",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform/ENGINEERING_PLATFORM_VERSION.json

@@ -1,15 +1,15 @@
 {
   "bootstrap_contract": "2026.12",
   "checkpoint_format": 1,
-  "dashboard_version": "2.3.96",
+  "dashboard_version": "2.3.97",
   "handoff_protocol": 1,
   "memory_format": 2,
   "minimum_codex_cli": "0.146.0",
   "inbox_protocol": 1,
-  "platform_version": "2.3.96",
+  "platform_version": "2.3.97",
   "report_format": 2,
-  "runner_version": "2.3.96",
+  "runner_version": "2.3.97",
   "status_model": 1,
   "storage_schema": 45,
-  "watcher_version": "2.3.96"
+  "watcher_version": "2.3.97"
 }

engineering_platform-2.3.97/src/engineering_platform/managed_workspace_recovery.py

@@ -0,0 +1,174 @@
+"""Owner-operated recovery for one abandoned Managed execution checkout."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from hashlib import sha256
+import json
+import os
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import sqlite3
+import tempfile
+
+from .execution_errors import RunnerError
+from .execution_repository import SubprocessRepositoryClient
+from .local_repository_binding import resolve_execution_repository
+from .providers import GitProvider
+
+
+class ManagedWorkspaceRecoveryError(ValueError):
+    """Stable fail-closed error for abandoned-workspace recovery."""
+
+
+_OPERATION = re.compile(r"[a-z0-9][a-z0-9-]{7,95}")
+_BRANCH = re.compile(r"(?!main$)[A-Za-z0-9][A-Za-z0-9._/-]{0,127}")
+_SHA = re.compile(r"[0-9a-f]{40}")
+_MAX_FILES = 2048
+_MAX_BYTES = 64 * 1024 * 1024
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _digest(path: Path) -> str:
+    value = sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            value.update(chunk)
+    return "sha256:" + value.hexdigest()
+
+
+def _command(provider: GitProvider, root: Path, *arguments: str) -> str:
+    try:
+        return provider.command(root, "git", *arguments)
+    except RuntimeError as error:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_GIT_FAILED") from error
+
+
+def _relative_untracked(provider: GitProvider, root: Path) -> tuple[Path, ...]:
+    raw = _command(provider, root, "ls-files", "--others", "--exclude-standard", "-z")
+    values = tuple(value for value in raw.split("\0") if value)
+    if len(values) > _MAX_FILES:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_TOO_MANY_FILES")
+    paths: list[Path] = []
+    total = 0
+    for value in values:
+        posix = PurePosixPath(value)
+        if posix.is_absolute() or not posix.parts or any(part in {"", ".", ".."} for part in posix.parts):
+            raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_PATH_INVALID")
+        source = root.joinpath(*posix.parts)
+        try:
+            metadata = source.lstat()
+        except OSError as error:
+            raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_SOURCE_UNAVAILABLE") from error
+        if not source.is_file() or source.is_symlink():
+            raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_SOURCE_UNSUPPORTED")
+        total += metadata.st_size
+        if total > _MAX_BYTES:
+            raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_TOO_LARGE")
+        paths.append(source)
+    return tuple(paths)
+
+
+def _write_recovery_backup(*, root: Path, destination: Path, operation_id: str,
+                           project_id: str, repository_id: str, branch: str,
+                           head_sha: str, provider: GitProvider) -> dict[str, object]:
+    destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if destination.exists():
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_DESTINATION_EXISTS")
+    staging = Path(tempfile.mkdtemp(prefix=f".{operation_id}-", dir=destination.parent))
+    os.chmod(staging, 0o700)
+    try:
+        patch = staging / "tracked.patch"
+        patch.write_text(_command(provider, root, "diff", "--binary", "--full-index", "HEAD"), encoding="utf-8")
+        patch.chmod(0o600)
+        untracked_root = staging / "untracked"
+        untracked_root.mkdir(mode=0o700)
+        files: list[dict[str, object]] = []
+        for source in _relative_untracked(provider, root):
+            relative = source.relative_to(root)
+            target = untracked_root / relative
+            target.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+            shutil.copyfile(source, target, follow_symlinks=False)
+            target.chmod(0o600)
+            if _digest(source) != _digest(target):
+                raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_BACKUP_MISMATCH")
+            files.append({"path": relative.as_posix(), "size": target.stat().st_size,
+                          "sha256": _digest(target)})
+        manifest: dict[str, object] = {
+            "contract_version": "managed-workspace-recovery/v1",
+            "operation_id": operation_id, "project_id": project_id,
+            "repository_id": repository_id, "branch": branch, "head_sha": head_sha,
+            "created_at": _now(), "tracked_patch": {"path": "tracked.patch", "sha256": _digest(patch)},
+            "untracked_files": files,
+        }
+        manifest_path = staging / "manifest.json"
+        manifest_path.write_text(json.dumps(manifest, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+        manifest_path.chmod(0o600)
+        os.replace(staging, destination)
+        return manifest
+    except Exception:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+
+
+def recover(*, connection: sqlite3.Connection, data_root: Path, project_id: str,
+            repository_id: str, operation_id: str, expected_branch: str,
+            expected_head: str, backup_root: Path,
+            provider: GitProvider | None = None) -> dict[str, object]:
+    """Preserve abandoned WIP, restore synchronized main, and remove its local branch."""
+    if _OPERATION.fullmatch(operation_id) is None:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_OPERATION_INVALID")
+    if _BRANCH.fullmatch(expected_branch) is None or ".." in expected_branch or expected_branch.endswith("/"):
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_BRANCH_INVALID")
+    if _SHA.fullmatch(expected_head) is None:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_HEAD_INVALID")
+    try:
+        backup_root = backup_root.expanduser().resolve()
+        data_root = data_root.resolve()
+    except OSError as error:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_PATH_UNAVAILABLE") from error
+    if backup_root == data_root or backup_root.is_relative_to(data_root):
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_BACKUP_UNSAFE")
+    active = connection.execute(
+        "SELECT COUNT(*) FROM execution_run_leases WHERE lease_state='ACTIVE'"
+    ).fetchone()
+    if active is None or int(active[0]) != 0:
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_ACTIVE_LEASE")
+    binding = resolve_execution_repository(
+        connection, project_id=project_id, repository_id=repository_id, data_root=data_root,
+    )
+    root = binding.local_root
+    git = provider or GitProvider()
+    client = SubprocessRepositoryClient(git)
+    before = client.inspect(root)
+    if (before.branch != expected_branch or before.head_sha != expected_head
+            or before.repository != client.trusted_origin_identity(root)
+            or client.workspace_operation_active(root)):
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_EXPECTATION_MISMATCH")
+    destination = backup_root / operation_id
+    manifest = _write_recovery_backup(
+        root=root, destination=destination, operation_id=operation_id,
+        project_id=project_id, repository_id=repository_id, branch=expected_branch,
+        head_sha=expected_head, provider=git,
+    )
+    _command(git, root, "reset", "--hard", expected_head)
+    _command(git, root, "clean", "-fd")
+    client.synchronize_main(root)
+    if git.execute(root, "git", "show-ref", "--verify", "--quiet", f"refs/heads/{expected_branch}").returncode == 0:
+        _command(git, root, "branch", "-D", expected_branch)
+    after = client.inspect(root)
+    if (after.branch != "main" or not after.clean or not after.main_contains_head
+            or after.repository != before.repository):
+        raise ManagedWorkspaceRecoveryError("MANAGED_WORKSPACE_RECOVERY_RESULT_UNCERTAIN")
+    receipt = {
+        **manifest, "completed_at": _now(), "result": "RECOVERED",
+        "backup_path": str(destination), "final_branch": after.branch,
+        "final_head_sha": after.head_sha, "final_clean": after.clean,
+    }
+    receipt_path = destination / "receipt.json"
+    receipt_path.write_text(json.dumps(receipt, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+    receipt_path.chmod(0o600)
+    return receipt

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform/platform_version.py

@@ -12,7 +12,7 @@ from .storage import ENGINEERING_STORAGE_SCHEMA_VERSION
 
 SEMVER = re.compile(r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$")
 CONTRACT = re.compile(r"^(\d{4})\.(0[1-9]|1[0-2])$")
-CURRENT_PLATFORM_VERSION = "2.3.96"
+CURRENT_PLATFORM_VERSION = "2.3.97"
 MANIFEST_FIELDS = frozenset(
     {
         "platform_version",

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform/server.py

@@ -78,6 +78,7 @@ from . import storage
 from . import telemetry_export
 from . import managed_codex_runtime
 from . import managed_workspace_readiness
+from . import managed_workspace_recovery
 from . import provider_readiness
 from .platform_components import (
     PLATFORM_COMPONENT_BY_ID,
@@ -7544,7 +7545,7 @@ def health(data_root: Path) -> dict[str, object]:
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="engineering-platform-server", description="Manage the standalone Engineering Platform Server foundation")
-    parser.add_argument("command", choices=("init", "start", "serve", "stop", "status", "health", "operational-diagnose", "operational-qualify", "operational-readback", "operational-update-assess", "operational-inventory", "system-service-inventory", "legacy-adoption-inspect", "legacy-adoption-authorize", "installation-update-plan", "installation-update-prepare", "installation-update-admit", "installation-update-apply", "installation-update-resume", "installation-update-status", "owner-consumer-readback", "owner-credential-recover", "owner-credential-recovery-adopt-peer-configuration", "owner-credential-recovery-status", "service-install", "service-uninstall", "relay-install", "relay-uninstall", "pairing-create", "agent-status", "agent-revoke", "agent-reset", "topology", "submission-diagnose", "bootstrap-topology", "register-topology", "provision-declaration", "issue-consumer-credential", "issue-development-consumer-credential", "grant-operator-capability", "revoke-operator-capability", "inspect-assurance-target", "select-assurance-target", "revoke-assurance-target", "reserve-merge-delegation", "activate-merge-delegation", "revoke-merge-delegation", "bind-repository", "rebind-repository", "unbind-repository", "resolve-repository", "register-producer-binding", "list-producer-bindings", "deactivate-producer-binding"))
+    parser.add_argument("command", choices=("init", "start", "serve", "stop", "status", "health", "operational-diagnose", "operational-qualify", "operational-readback", "operational-update-assess", "operational-inventory", "system-service-inventory", "legacy-adoption-inspect", "legacy-adoption-authorize", "installation-update-plan", "installation-update-prepare", "installation-update-admit", "installation-update-apply", "installation-update-resume", "installation-update-status", "owner-consumer-readback", "owner-credential-recover", "owner-credential-recovery-adopt-peer-configuration", "owner-credential-recovery-status", "service-install", "service-uninstall", "relay-install", "relay-uninstall", "pairing-create", "agent-status", "agent-revoke", "agent-reset", "topology", "submission-diagnose", "bootstrap-topology", "register-topology", "provision-declaration", "issue-consumer-credential", "issue-development-consumer-credential", "grant-operator-capability", "revoke-operator-capability", "inspect-assurance-target", "select-assurance-target", "revoke-assurance-target", "reserve-merge-delegation", "activate-merge-delegation", "revoke-merge-delegation", "bind-repository", "rebind-repository", "unbind-repository", "resolve-repository", "recover-managed-workspace", "register-producer-binding", "list-producer-bindings", "deactivate-producer-binding"))
     parser.add_argument("--data-root", type=Path, default=default_data_root())
     parser.add_argument("--runtime-profile", choices=("operational", "development"), default="operational")
     parser.add_argument("--development-venv", type=Path)
@@ -7565,6 +7566,9 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--reason")
     parser.add_argument("--capability", choices=("QUEUE_HOLD_RESUME", "QUEUE_DECLINE"))
     parser.add_argument("--operation-id")
+    parser.add_argument("--expected-branch")
+    parser.add_argument("--expected-head")
+    parser.add_argument("--backup-root", type=Path)
     parser.add_argument("--delegation-id")
     parser.add_argument("--mission-id")
     parser.add_argument("--mission-revision")
@@ -8593,6 +8597,27 @@ def main(argv: list[str] | None = None) -> int:
                 target.write_text(json.dumps(declaration, sort_keys=True, indent=2) + "\n", encoding="utf-8")
                 target.chmod(0o600)
             result = {"project_id": args.project_id, "repository_id": args.repository_id, "path": str(target), "result": "PROVISIONED"}
+        elif args.command == "recover-managed-workspace":
+            if not all((args.project_id, args.repository_id, args.operation_id,
+                        args.expected_branch, args.expected_head)) or args.backup_root is None:
+                raise ServerConfigurationError(
+                    "Managed workspace recovery requires project, repository, operation, expected branch/head and backup root."
+                )
+            if status(args.data_root)["running"]:
+                raise ServerConfigurationError("MANAGED_WORKSPACE_RECOVERY_SERVER_ACTIVE")
+            initialize(args.data_root)
+            try:
+                from .platform_admin import require_installation_owner
+                require_installation_owner(args.data_root)
+                with storage.sqlite_connection(args.data_root / SERVER_DATABASE_FILENAME) as connection:
+                    result = managed_workspace_recovery.recover(
+                        connection=connection, data_root=args.data_root,
+                        project_id=args.project_id, repository_id=args.repository_id,
+                        operation_id=args.operation_id, expected_branch=args.expected_branch,
+                        expected_head=args.expected_head, backup_root=args.backup_root,
+                    )
+            except PermissionError as error:
+                raise ServerConfigurationError("PLATFORM_ADMIN_FORBIDDEN") from error
         elif args.command in {"bind-repository", "rebind-repository", "unbind-repository", "resolve-repository"}:
             if not args.project_id or not args.repository_id:
                 raise ServerConfigurationError("--project-id and --repository-id are required for local binding commands.")
@@ -8637,6 +8662,7 @@ def main(argv: list[str] | None = None) -> int:
             server_service.ServerServiceError,
             development_profile.DevelopmentProfileError,
             local_repository_binding.LocalRepositoryBindingError,
+            managed_workspace_recovery.ManagedWorkspaceRecoveryError,
             external_producer_binding.ProducerBindingError) as error:
         print(json.dumps({"error": str(error), "ready": False}, sort_keys=True))
         return 2

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform/templates/workspace-config.json

@@ -3,7 +3,7 @@
   "platform": {
     "id": "engineering-platform",
     "name": "Engineering Platform",
-    "version": "2.3.96",
+    "version": "2.3.97",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-platform
-Version: 2.3.96
+Version: 2.3.97
 Summary: Local-first Engineering Platform execution operations runtime
 Author: Peter van Tol
 License: MIT

{engineering_platform-2.3.96 → engineering_platform-2.3.97}/src/engineering_platform.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/engineering_platform/local_repository_binding.py
 src/engineering_platform/managed_autonomy.py
 src/engineering_platform/managed_codex_runtime.py
 src/engineering_platform/managed_workspace_readiness.py
+src/engineering_platform/managed_workspace_recovery.py
 src/engineering_platform/merge_delegation.py
 src/engineering_platform/operational_installation.py
 src/engineering_platform/operational_installation_lock.py