mru-cli 0.1.2__py3-none-any.whl

mru_cli/__init__.py

@@ -0,0 +1 @@
+"""MRU terminal client."""

mru_cli/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+raise SystemExit(main())

mru_cli/main.py

@@ -0,0 +1,377 @@
+"""Terminal deployment flow for the MRU-owned physical bottle cell."""
+import argparse
+import getpass
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlparse
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+import uuid
+
+from .manifest import checkpoint_digest
+from .project import init_project, load_project
+
+
+class CliError(Exception):
+    pass
+
+
+class NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def checked_url(url):
+    parsed = urlparse(url)
+    if (not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment
+            or parsed.path not in ("", "/")
+            or not (parsed.scheme == "https" or parsed.scheme == "http" and parsed.hostname in ("localhost", "127.0.0.1", "::1"))):
+        raise CliError("Use an HTTPS MRU website origin (HTTP is allowed only for localhost)")
+    return url.rstrip("/")
+
+
+class Client:
+    def __init__(self, url, token):
+        self.url = checked_url(url)
+        if not token.startswith("mru_cli_"):
+            raise CliError("Create a CLI token in the Deployments dashboard, then run mru login")
+        self.token = token
+
+    def request(self, path, body=None):
+        data = json.dumps(body).encode() if body is not None else None
+        request = Request(self.url + "/api/cli" + path, data=data,
+            headers={"Authorization": "Bearer " + self.token, "Content-Type": "application/json"})
+        try:
+            with build_opener(NoRedirect).open(request, timeout=30) as response:
+                return json.load(response)
+        except HTTPError as exc:
+            try:
+                detail = json.load(exc).get("detail", f"HTTP {exc.code}")
+            except (ValueError, AttributeError):
+                detail = f"HTTP {exc.code}"
+            raise CliError(str(detail)) from exc
+        except (URLError, TimeoutError) as exc:
+            raise CliError("MRU connection failed; a submitted request may have been accepted. Reuse its request ID when retrying.") from exc
+
+
+def config_path():
+    return Path(os.environ.get("MRU_CONFIG", str(Path.home() / ".config/mru/config.json")))
+
+
+def read_config():
+    path = config_path()
+    return json.loads(path.read_text()) if path.exists() else {}
+
+
+def save_config(value):
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    descriptor, temporary = tempfile.mkstemp(dir=path.parent, prefix=".mru-")
+    try:
+        with os.fdopen(descriptor, "w") as handle:
+            json.dump(value, handle)
+        os.replace(temporary, path)
+    finally:
+        Path(temporary).unlink(missing_ok=True)
+
+
+def segment(value):
+    return quote(value, safe="")
+
+
+def publish_inference(manifest, local_checkpoint=None):
+    import modal
+    if local_checkpoint:
+        print("Uploading checkpoint and processors…", file=sys.stderr)
+        volume = modal.Volume.from_name(manifest["volume"])
+        # The destination is derived from the contents, never a user's training path.
+        with volume.batch_upload(force=True) as batch:
+            batch.put_directory(str(local_checkpoint), manifest["checkpoint"].removeprefix("/store"))
+        if checkpoint_digest(local_checkpoint) != manifest["checkpointDigest"]:
+            raise CliError("Checkpoint changed during upload; save a stable checkpoint and deploy again")
+    with tempfile.TemporaryDirectory(prefix="mru-deploy-") as directory:
+        path = Path(directory) / "manifest.json"
+        path.write_text(json.dumps(manifest))
+        result = subprocess.run([sys.executable, "-m", "modal", "deploy", "-m",
+            "mru_cli.modal_inference"],
+            env={**os.environ, "MRU_BOTTLE_MANIFEST": str(path)}, stdout=sys.stderr, stderr=sys.stderr)
+        if result.returncode:
+            raise CliError("Inference publication failed. The deployment remains resumable; rerun the same deploy command.")
+
+
+def wait_for(client, identifier, timeout):
+    deadline = time.monotonic() + timeout
+    previous = None
+    deployment = identifier.startswith("deployment:")
+    path = "/v1/" + ("deployments/" if deployment else "evaluations/") + segment(identifier)
+    while True:
+        result = client.request(path)
+        state = result["deployment"]["status"] if deployment else result["summary"]["status"]
+        message = result["deployment"].get("message", "") if deployment else next(
+            (item["run"].get("provenance", {}).get("message", "") for item in result.get("runs", [])), "")
+        activity = (state, message)
+        if activity != previous:
+            print(state.replace("_", " ") + (" · " + message if message else ""), file=sys.stderr)
+            previous = activity
+        if state in {"deployed", "completed", "failed", "cancelled"}:
+            return result
+        if time.monotonic() >= deadline:
+            raise CliError(f"Stopped waiting; the job is unchanged. Resume with: mru status {identifier} --watch")
+        time.sleep(3)
+
+
+def output(value, as_json):
+    if as_json:
+        print(json.dumps(value, indent=2))
+    elif value.get("target") == "local" and "box" in value:
+        box = value["box"]
+        active = next((model for model in box.get("deployments", []) if model["id"] == box.get("active_id")), {})
+        print("Ethernet box: " + ("running" if box.get("running") else "stopped"))
+        print("Loaded model: " + active.get("name", "none"))
+        print("Robot contract: " + str(active.get("state_dim", "?")) + " state / " + str(active.get("action_dim", "?")) + " action values")
+        operation = value.get("operation") or {}
+        if operation:
+            progress = "Staging: " + operation.get("phase", "unknown").replace("_", " ")
+            if operation.get("totalBytes"):
+                progress += f" · {operation.get('receivedBytes', 0) / 1024**3:.2f} / {operation['totalBytes'] / 1024**3:.2f} GiB"
+            print(progress)
+        print("Client: " + ("ready" if value["client"]["ready"] else value["client"]["error"]))
+    elif "deployment" in value:
+        doc = value["deployment"]
+        print(f"{doc['id']}  {doc['name']}\n{doc['status'].replace('_', ' ')} · {doc['message']}")
+        if "robot" in value:
+            print("Robot: " + value["robot"]["reason"])
+    elif "evaluation" in value:
+        print(f"{value['evaluation']['id']}  {value['summary']['status']}")
+        for run in value["runs"]:
+            print(run["run"].get("provenance", {}).get("message", "Task outcome remains unverified"))
+    elif "deployments" in value:
+        for doc in value["deployments"]:
+            print(f"{doc['id']}  {doc['status']:20}  {doc['name']}")
+        if not value["deployments"]:
+            print("No deployments yet. Use mru deploy mru.json")
+        print("Robot: " + value["robot"]["reason"])
+    else:
+        print(json.dumps(value, indent=2))
+
+
+def parser():
+    root = argparse.ArgumentParser(description=__doc__)
+    root.add_argument("--url", help="MRU website origin; defaults to MRU_URL or saved login")
+    root.add_argument("--json", action="store_true", help="Print machine-readable results")
+    commands = root.add_subparsers(dest="command", required=True)
+    commands.add_parser("login", help="Save a dashboard CLI token using a hidden prompt")
+    commands.add_parser("logout", help="Remove saved local credentials")
+    commands.add_parser("deployments", help="List checkpoint releases")
+    target = commands.add_parser("target", help="Select Modal or Ethernet inference for new deployments")
+    targets = target.add_subparsers(dest="target_command", required=True)
+    use = targets.add_parser("use", help="Save the default inference target on this computer")
+    use.add_argument("name", choices=("modal", "local"))
+    use.add_argument("--relay", help="Devbox relay origin, reached over Tailscale")
+    targets.add_parser("show", help="Show this computer's default target")
+    targets.add_parser("status", help="Inspect the Ethernet inference box through the Devbox")
+    targets.add_parser("logs", help="Show Ethernet inference worker logs")
+    upload = targets.add_parser("upload", help="Upload a checkpoint and run GPU-box warm inference without robot execution")
+    upload.add_argument("checkpoint", type=Path)
+    upload.add_argument("--name", help="Name in the Ethernet box model library")
+    pull = targets.add_parser("pull", help="Load an owned Modal release's checkpoint on the Ethernet box without a Mac upload")
+    pull.add_argument("deployment")
+    pull.add_argument("--name", help="Name in the Ethernet box model library")
+    init = commands.add_parser("init", help="Create a standalone robot job folder")
+    init.add_argument("directory", type=Path)
+    init.add_argument("--type", choices=("act", "pi05"), default="act", dest="policy_type")
+    init.add_argument("--volume", default="", help="Existing Modal checkpoint volume")
+    init.add_argument("--runtime-image", default="", help="Validated Modal runtime image ID")
+    init.add_argument("--rate-hz", type=int, choices=(30, 50), default=30)
+    check = commands.add_parser("check", help="Validate job settings and hash the checkpoint locally")
+    check.add_argument("manifest", type=Path, nargs="?", default=Path("."), help="Job folder or JSON manifest")
+    check.add_argument("--checkpoint", type=Path, help="Override the local checkpoint directory")
+    check.add_argument("--target", choices=("modal", "local"))
+    check.add_argument("--task", help="Exact training instruction for local pi05")
+    digest = commands.add_parser("digest", help="Hash a saved checkpoint, including processors")
+    digest.add_argument("directory", type=Path)
+    deploy = commands.add_parser("deploy", help="Upload, validate and queue a physical robot task")
+    deploy.add_argument("manifest", type=Path, nargs="?", default=Path("."), help="Job folder or physical inference JSON manifest (default: current folder)")
+    deploy.add_argument("--checkpoint", type=Path, help="Upload a complete saved local checkpoint")
+    deploy.add_argument("--target", choices=("modal", "local"), help="Override mru target use for this deployment")
+    deploy.add_argument("--task", help="Exact training instruction for local pi05")
+    deploy.add_argument("--wait", action="store_true", help="Watch the robot task through completion")
+    deploy.add_argument("--no-run", action="store_true", help="Publish and validate only; do not queue robot execution")
+    deploy.add_argument("--auto", action="store_true", help="Authorize this job to execute without a local AUTO prompt")
+    deploy.add_argument("--request-id", help="Reuse after an uncertain deployment submission to avoid a duplicate task")
+    validate = commands.add_parser("validate", help="Retry loading an already published release")
+    validate.add_argument("identifier")
+    run = commands.add_parser("run", help="Queue another robot task from a published release")
+    run.add_argument("identifier")
+    run.add_argument("--request-id", help="Reuse this value after an uncertain submission")
+    run.add_argument("--wait", action="store_true")
+    run.add_argument("--auto", action="store_true", help="Authorize this job to execute without a local AUTO prompt")
+    status = commands.add_parser("status", help="Inspect a deployment or evaluation")
+    status.add_argument("identifier")
+    status.add_argument("--watch", action="store_true")
+    logs = commands.add_parser("logs", help="Show persisted deployment activity and run messages")
+    logs.add_argument("identifier")
+    cancel = commands.add_parser("cancel", help="Request stop for an evaluation; local stop confirmation is still required")
+    cancel.add_argument("identifier")
+    for command in (deploy, run, status):
+        command.add_argument("--timeout", type=int, default=900, help="Maximum wait in seconds")
+    return root
+
+
+def execute(args):
+    config = read_config()
+    if args.command == "target" and args.target_command in {"use", "show"}:
+        from .targets import DEFAULT_RELAY, relay_origin
+        if args.target_command == "use":
+            config["inferenceTarget"] = args.name
+            if args.relay:
+                config["localRelay"] = relay_origin(args.relay)
+            save_config(config)
+        print(json.dumps({"target": config.get("inferenceTarget", "modal"),
+                          "localRelay": config.get("localRelay", DEFAULT_RELAY)}))
+        return 0
+    if args.command == "deploy" and args.auto and args.no_run:
+        raise CliError("--auto cannot be combined with --no-run")
+    if args.command == "init":
+        directory = init_project(args.directory, policy_type=args.policy_type, volume=args.volume,
+                                 runtime_image=args.runtime_image, rate_hz=args.rate_hz)
+        if args.json:
+            print(json.dumps({"directory": str(directory), "manifest": str(directory / "mru.json")}))
+        else:
+            print(f"Created robot job at {directory}\nAdd your saved checkpoint to checkpoint/ and configure mru.json.\nThen run mru check from the job folder.")
+        return 0
+    if args.command == "check":
+        manifest, checkpoint = load_project(args.manifest, args.checkpoint,
+            target=args.target or config.get("inferenceTarget"), task=args.task)
+        if args.json:
+            print(json.dumps({"manifest": manifest, "localCheckpoint": str(checkpoint.resolve()) if checkpoint else None}, indent=2))
+        else:
+            print(f"Job settings valid: {manifest['name']} ({manifest['type']})\nCheckpoint SHA-256: {manifest['checkpointDigest']}\nLocal checks only; model loading and robot compatibility still require deployment validation.")
+        return 0
+    if args.command == "digest":
+        print(checkpoint_digest(args.directory))
+        return 0
+    if args.command == "logout":
+        config_path().unlink(missing_ok=True)
+        print("Local credentials removed. Revoke the token in the dashboard to invalidate it.")
+        return 0
+    url = args.url or os.environ.get("MRU_URL") or config.get("url", "https://app.makerobotsuseful.com")
+    token = os.environ.get("MRU_TOKEN") or config.get("token", "")
+    if args.command == "login":
+        token = getpass.getpass("CLI token from the Deployments dashboard: ").strip()
+    client = Client(url, token)
+    if args.command == "login":
+        client.request("/v1/me")
+        save_config({**config, "url": client.url, "token": token})
+        print("Connected to " + client.url)
+        return 0
+    if args.command == "deploy":
+        manifest, checkpoint = load_project(args.manifest, args.checkpoint,
+            target=args.target or config.get("inferenceTarget"), task=args.task)
+        local = manifest.get("inferenceTarget") == "local"
+        if local:
+            from .targets import LocalTarget, DEFAULT_RELAY
+            local_target = LocalTarget(token, config.get("localRelay", DEFAULT_RELAY))
+            readiness = local_target.request("/v1/status")["client"]
+            if not readiness["ready"]:
+                raise CliError("Local inference client is not ready: " + readiness["error"])
+            if checkpoint is None and not local_target.request("/v1/staged/" + manifest["checkpointDigest"])["available"]:
+                raise CliError("Checkpoint is not staged on the Ethernet box; use --checkpoint or mru target pull first")
+        request_id = args.request_id or uuid.uuid4().hex
+        if not args.no_run:
+            print(f"Request ID: {request_id} (reuse with --request-id when retrying this deploy)", file=sys.stderr)
+            print("This job is authorized to start physical execution when the robot is ready." if args.auto else
+                  "This deployment queues a physical task; it runs when local automatic mode is enabled.", file=sys.stderr)
+        result = client.request("/v1/deployments", manifest)
+        doc = result["deployment"]
+        identifier = doc["id"]
+        print(identifier, file=sys.stderr)
+        print(client.url + "/deployments?deployment=" + segment(identifier), file=sys.stderr)
+        if not local and doc["status"] not in {"deployed", "validating"}:
+            publish_inference(doc["manifest"], checkpoint)
+        result = client.request("/v1/deployments/" + segment(identifier) + "/validate", {})
+        if local and result["deployment"]["status"] != "deployed":
+            print("Publishing checkpoint to the Ethernet GPU box through the resident Devbox relay…", file=sys.stderr)
+            local_target.publish(identifier, checkpoint, manifest["checkpointDigest"])
+            result = client.request("/v1/deployments/" + segment(identifier))
+        if args.wait or not args.no_run:
+            result = wait_for(client, identifier, args.timeout)
+        if not args.no_run and result["deployment"]["status"] == "deployed":
+            result = client.request("/v1/deployments/" + segment(identifier) + "/runs",
+                                    {"requestId": request_id, **({"auto": True} if args.auto else {})})
+            print(result["evaluation"]["id"], file=sys.stderr)
+            if args.wait:
+                result = wait_for(client, result["evaluation"]["id"], args.timeout)
+    elif args.command == "target":
+        from .targets import LocalTarget, DEFAULT_RELAY
+        target = LocalTarget(token, config.get("localRelay", DEFAULT_RELAY))
+        if args.target_command == "upload":
+            result = target.stage(args.checkpoint, args.name)
+        elif args.target_command == "pull":
+            print("Devbox is fetching the saved checkpoint, then loading and warming the Ethernet GPU box…", file=sys.stderr)
+            print("Progress: mru target status", file=sys.stderr)
+            result = target.pull(args.deployment, args.name)
+        else:
+            result = target.request("/v1/" + args.target_command)
+    elif args.command == "deployments":
+        result = client.request("/v1/deployments")
+    elif args.command == "validate":
+        result = client.request("/v1/deployments/" + segment(args.identifier) + "/validate", {})
+        doc = result["deployment"]
+        if doc["manifest"].get("inferenceTarget") == "local" and doc["status"] != "deployed":
+            from .targets import LocalTarget, DEFAULT_RELAY
+            target = LocalTarget(token, config.get("localRelay", DEFAULT_RELAY))
+            target.publish(args.identifier, None, doc["manifest"]["checkpointDigest"])
+            result = client.request("/v1/deployments/" + segment(args.identifier))
+    elif args.command == "run":
+        request_id = args.request_id or uuid.uuid4().hex
+        print(f"Request ID: {request_id} (reuse with --request-id if the response is lost)", file=sys.stderr)
+        if args.auto:
+            print("This job is authorized to start physical execution when the robot is ready.", file=sys.stderr)
+        result = client.request("/v1/deployments/" + segment(args.identifier) + "/runs",
+                                {"requestId": request_id, **({"auto": True} if args.auto else {})})
+        if args.wait:
+            print(result["evaluation"]["id"], file=sys.stderr)
+            result = wait_for(client, result["evaluation"]["id"], args.timeout)
+    elif args.command == "cancel":
+        result = client.request("/v1/evaluations/" + segment(args.identifier) + "/cancel", {})
+    else:
+        if args.command == "status" and args.watch:
+            result = wait_for(client, args.identifier, args.timeout)
+        else:
+            resource = "deployments" if args.identifier.startswith("deployment:") else "evaluations"
+            result = client.request(f"/v1/{resource}/" + segment(args.identifier))
+        if args.command == "logs":
+            entries = list(result.get("deployment", {}).get("events", []))
+            evaluations = result.get("evaluations", [result] if "evaluation" in result else [])
+            for view in evaluations:
+                for item in view["runs"]:
+                    run = item["run"]
+                    entries.append({"at": run.get("endedAt") or run["createdAt"],
+                        "message": run["status"] + " · " + run.get("provenance", {}).get("message", "Task outcome unverified")})
+            if args.json:
+                print(json.dumps(entries, indent=2))
+            else:
+                for entry in entries:
+                    print(f"{entry['at']}  {entry['message']}")
+            return 0
+    output(result, args.json)
+    status = result.get("deployment", {}).get("status") or result.get("summary", {}).get("status")
+    return 1 if status in {"failed", "cancelled"} else 0
+
+
+def main(argv=None):
+    args = parser().parse_args(argv)
+    try:
+        return execute(args)
+    except (CliError, ValueError, OSError) as exc:
+        print(f"mru: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("Stopped waiting; inspect the deployment or run before submitting again.", file=sys.stderr)
+        return 130

mru_cli/manifest.py

@@ -0,0 +1,84 @@
+"""Shared, dependency-free contract for physical checkpoint releases."""
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+
+DEPLOYMENT_PROTOCOL = "mru.physical-deployment/v1"
+MAX_CYCLES = 30
+JOINT_ORDER = ["finger_joint1", *[f"joint{i}" for i in range(1, 8)]]
+
+
+def require_policy_attestation(policy, reply):
+    if not isinstance(reply, dict):
+        raise ValueError("Inference attestation must be an object")
+    if policy.get("manifestDigest") and reply.get("manifestDigest") != policy["manifestDigest"]:
+        raise ValueError("Inference release does not match the deployed manifest")
+    if reply.get("checkpointDigest") != policy["checkpointDigest"] or reply.get("fps") != policy["rateHz"]:
+        raise ValueError("Inference checkpoint/control rate does not match assignment")
+    if reply.get("joint_order") != JOINT_ORDER:
+        raise ValueError("Inference joint ordering mismatch")
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
+
+
+def manifest_digest(manifest):
+    return hashlib.sha256(canonical(manifest).encode()).hexdigest()
+
+
+def validate_manifest(value):
+    if not isinstance(value, dict):
+        raise ValueError("Manifest must be a JSON object")
+    local = value.get("inferenceTarget") == "local"
+    required = {"name", "type", "checkpoint", "checkpointDigest", "rateHz"}
+    required |= {"inferenceTarget", "task"} if local else {"volume", "runtimeImageId"}
+    if not required <= value.keys() or value.keys() - required - {"cycles"}:
+        raise ValueError("Manifest requires " + ", ".join(sorted(required)) + "; cycles is optional")
+    if not isinstance(value["name"], str) or not 1 <= len(value["name"].strip()) <= 80:
+        raise ValueError("name must contain 1–80 characters")
+    if value["type"] not in ("act", "pi05"):
+        raise ValueError("Only physical bottle ACT and pi05 checkpoints are supported")
+    if local and (value["type"] != "pi05" or not isinstance(value["task"], str)
+                  or not 1 <= len(value["task"].strip()) <= 2000):
+        raise ValueError("The local target requires pi05 and its training task instruction")
+    patterns = [("checkpointDigest", r"[a-f0-9]{64}")]
+    if not local:
+        patterns += [("volume", r"[A-Za-z0-9][A-Za-z0-9_-]{0,63}"), ("runtimeImageId", r"im-[A-Za-z0-9]+")]
+    for key, pattern in patterns:
+        if not isinstance(value[key], str) or not re.fullmatch(pattern, value[key]):
+            raise ValueError(f"Invalid {key}")
+    checkpoint = value["checkpoint"]
+    if (not isinstance(checkpoint, str) or not checkpoint.startswith("/store/")
+            or any(part in (".", "..") for part in checkpoint.split("/"))
+            or str(PurePosixPath(checkpoint)) != checkpoint or len(checkpoint) > 500):
+        raise ValueError("checkpoint must be a normalized directory under /store")
+    if type(value["rateHz"]) is not int or value["rateHz"] not in (30, 50):
+        raise ValueError("rateHz must be the checkpoint's learned rate: 30 or 50")
+    cycles = value.get("cycles", 5)
+    if type(cycles) is not int or not 1 <= cycles <= MAX_CYCLES:
+        raise ValueError(f"cycles must be between 1 and {MAX_CYCLES}")
+    return {**value, "name": value["name"].strip(), "cycles": cycles}
+
+
+def checkpoint_digest(directory):
+    directory = Path(directory)
+    if directory.is_symlink() or not directory.is_dir():
+        raise ValueError("Checkpoint must be a real directory")
+    result = hashlib.sha256()
+    files = 0
+    for path in sorted(directory.rglob("*")):
+        if path.is_symlink():
+            raise ValueError("Checkpoint symlinks are not supported")
+        if not path.is_file():
+            continue
+        files += 1
+        digest = hashlib.sha256()
+        with path.open("rb") as handle:
+            for block in iter(lambda: handle.read(1024 * 1024), b""):
+                digest.update(block)
+        result.update(path.relative_to(directory).as_posix().encode() + b"\0" + digest.digest())
+    if not files:
+        raise ValueError("Checkpoint directory is empty")
+    return result.hexdigest()

mru_cli/modal_inference.py

@@ -0,0 +1,122 @@
+"""Deploy a separately pinned bottle checkpoint; returns predictions only.
+
+Set MRU_BOTTLE_MANIFEST to an immutable local JSON manifest before modal deploy.
+This app has no device credential, robot connection or training entrypoint.
+"""
+import json
+import os
+from pathlib import Path
+
+import modal
+from mru_cli.manifest import DEPLOYMENT_PROTOCOL, checkpoint_digest, manifest_digest
+
+MANIFEST_PATH = Path(os.environ.get("MRU_BOTTLE_MANIFEST", "/opt/bottle-manifest.json"))
+MANIFEST = json.loads(MANIFEST_PATH.read_text())
+if MANIFEST["type"] not in {"act", "pi05"} or MANIFEST["rateHz"] not in (30, 50):
+    raise ValueError("Manifest requires ACT/pi05 and exact learned control rate")
+app = modal.App(MANIFEST["modalApp"])
+volume = modal.Volume.from_name(MANIFEST["volume"])
+image = (modal.Image.from_id(MANIFEST["runtimeImageId"])
+         .env({"TOKENIZERS_PARALLELISM": "false"})
+         .add_local_python_source("mru_cli", copy=True)
+         .add_local_file(MANIFEST_PATH, "/opt/bottle-manifest.json", copy=True))
+
+
+@app.cls(image=image, gpu="L4", cpu=4 if MANIFEST["type"] == "pi05" else 2,
+         memory=32768 if MANIFEST["type"] == "pi05" else 16384, volumes={"/store": volume},
+         secrets=[modal.Secret.from_name("huggingface-secret")],
+         timeout=600 if MANIFEST["type"] == "pi05" else 300, scaledown_window=300, max_containers=1,
+         retries=0)
+class Predictor:
+    @modal.enter()
+    def load(self):
+        import site
+        site.addsitedir("/opt/anvil/.venv/lib/python3.12/site-packages")
+        import torch
+        from safetensors.torch import load_file
+        from lerobot.configs.policies import PreTrainedConfig
+        from lerobot.processor import PolicyProcessorPipeline
+
+        volume.reload()
+        checkpoint = Path(MANIFEST["checkpoint"])
+        if not checkpoint.is_relative_to("/store") or not checkpoint.is_dir():
+            raise ValueError("Checkpoint must be a saved directory on the mounted volume")
+        if checkpoint_digest(checkpoint) != MANIFEST["checkpointDigest"]:
+            raise ValueError("Checkpoint/processor digest does not match the pinned manifest")
+        # LeRobot registers each policy's config when its module is imported.
+        # Register the selected family before decoding the saved config.
+        if MANIFEST["type"] == "pi05":
+            import lerobot.policies.pi05.configuration_pi05
+        else:
+            import lerobot.policies.act.configuration_act
+        config = PreTrainedConfig.from_pretrained(checkpoint)
+        if config.type != MANIFEST["type"]:
+            raise ValueError("Checkpoint policy type mismatch")
+        config.device = "cuda"
+        if config.type == "pi05":
+            from lerobot.policies.pi05 import PI05Policy
+            import lerobot.policies.pi05.processor_pi05
+            config.compile_model = False
+            names = ["right_finger_joint1", *[f"right_joint{i}" for i in range(1, 8)]]
+            if config.action_feature_names != names or config.use_relative_actions:
+                raise ValueError("PI05 must emit absolute right-arm positions in gripper-first order")
+            self.model = PI05Policy(config)
+            weights = load_file(str(checkpoint / "model.safetensors"))
+            weights = self.model._fix_pytorch_state_dict_keys(weights, config)
+            weights = {key if key.startswith("model.") else "model." + key: value for key, value in weights.items()}
+        else:
+            from lerobot.policies.act.modeling_act import ACTPolicy
+            import lerobot.policies.act.processor_act
+            self.model = ACTPolicy(config)
+            weights = load_file(str(checkpoint / "model.safetensors"))
+        self.model.load_state_dict(weights, strict=True)
+        del weights
+        self.model = self.model.to("cuda").eval()
+        self.pre = PolicyProcessorPipeline.from_pretrained(checkpoint, config_filename="policy_preprocessor.json")
+        self.post = PolicyProcessorPipeline.from_pretrained(checkpoint, config_filename="policy_postprocessor.json")
+        self.image_shapes = {key: feature.shape for key, feature in config.input_features.items() if key.startswith("observation.images.")}
+        expected = {"observation.images." + name for name in ("waist", "wrist_r", "chest")}
+        if set(self.image_shapes) != expected or tuple(config.output_features["action"].shape) != (8,):
+            raise ValueError("Checkpoint must match the physical bottle camera/eight-joint contract")
+
+    @modal.method()
+    def describe(self):
+        return {"checkpointDigest": MANIFEST["checkpointDigest"], "fps": MANIFEST["rateHz"],
+                "manifestDigest": manifest_digest(MANIFEST), "deploymentProtocol": DEPLOYMENT_PROTOCOL,
+                "joint_order": ["finger_joint1", *[f"joint{i}" for i in range(1, 8)]],
+                "checkpoint": MANIFEST["checkpoint"], "task_outcome": "unverified"}
+
+    @modal.method()
+    def predict(self, state: list[float], images: dict[str, bytes]):
+        import io
+        import time
+        import numpy as np
+        import torch
+        from PIL import Image, ImageOps
+
+        start = time.perf_counter()
+        array = np.asarray(state, dtype=np.float32)
+        if array.shape != (8,) or not np.isfinite(array).all() or set(images) != {"waist", "wrist_r", "chest"}:
+            raise ValueError("Expected eight finite gripper-first positions and three bottle cameras")
+        obs = {"observation.state": torch.from_numpy(array), "task": ["Pick up the bottle and hold it above the table."]}
+        for name, data in images.items():
+            if len(data) > 2_000_000:
+                raise ValueError("Camera payload exceeds 2 MB")
+            _, height, width = self.image_shapes["observation.images." + name]
+            with Image.open(io.BytesIO(data)) as source:
+                rgb = ImageOps.pad(source.convert("RGB"), (width, height), method=Image.Resampling.BILINEAR)
+                image = np.asarray(rgb).copy()
+            obs["observation.images." + name] = torch.from_numpy(image).permute(2, 0, 1).float() / 255
+        with torch.inference_mode():
+            torch.manual_seed(42)
+            batch = self.pre(obs)
+            batch = {key: value.to("cuda") if torch.is_tensor(value) else value for key, value in batch.items()}
+            chunk = self.model.predict_action_chunk(batch)
+            actions = torch.stack([self.post.process_action(chunk[:, index]) for index in range(chunk.shape[1])], dim=1)
+            result = actions.squeeze(0).cpu().numpy()
+        if result.ndim != 2 or result.shape[1] != 8 or not 1 <= result.shape[0] <= 100 or not np.isfinite(result).all():
+            raise RuntimeError("Invalid physical action chunk")
+        return {"checkpointDigest": MANIFEST["checkpointDigest"], "fps": MANIFEST["rateHz"],
+                "manifestDigest": manifest_digest(MANIFEST),
+                "joint_order": ["finger_joint1", *[f"joint{i}" for i in range(1, 8)]],
+                "actions": result.tolist(), "inference_ms": (time.perf_counter() - start) * 1000}

mru_cli/project.py

@@ -0,0 +1,92 @@
+"""Portable job directories for the built-in physical policy runner."""
+import json
+from pathlib import Path
+
+from .manifest import checkpoint_digest, validate_manifest
+
+
+JOB_README = """# MRU robot job
+
+This project uses MRU's built-in ACT/pi0.5 inference runner. You do not need to
+write Python inference code. The current task is the supported OpenARM bottle
+trial; custom tasks and inference scripts are not loaded from this folder.
+
+1. Copy your complete saved LeRobot checkpoint into `checkpoint/`, including
+   `config.json`, `model.safetensors`, saved pre/postprocessors and their files.
+2. Edit `mru.json`: set the existing Modal `volume` and validated
+   `runtimeImageId`, and match `type` and `rateHz` to your trained checkpoint.
+   `cycles` counts observe/predict/execute-chunk cycles within one trial.
+3. From this folder, run:
+
+   ```bash
+   mru check .
+   mru login
+   mru deploy . --wait
+   ```
+
+You can also use `mru deploy /path/to/this-folder` from any directory.
+The MRU CLI must already be installed, and Modal configured for the MRU workspace.
+Local checks validate the manifest and hash files; model loading happens on Modal.
+Deployment validates the checkpoint and queues its robot task. Once an operator
+enables automatic mode locally at the workcell, uploaded jobs execute without
+a per-job ARM prompt. Disabled/offline/busy workcells leave jobs in the queue.
+Use `mru deploy . --no-run` to publish a release without requesting execution.
+
+Only the configured checkpoint directory is uploaded. Source files, this README,
+and other project files are not uploaded. Keep credentials out of the checkpoint.
+`checkpointDir` is relative to `mru.json`; no absolute machine paths are needed.
+The included `.gitignore` keeps weights and local secrets out of Git. Share the
+project configuration through Git and supply checkpoint files separately.
+"""
+
+
+def init_project(directory, *, policy_type="act", volume="", runtime_image="", rate_hz=30):
+    directory = Path(directory)
+    if directory.exists() and (not directory.is_dir() or any(directory.iterdir())):
+        raise ValueError("Choose a new or empty directory; mru init does not overwrite existing files")
+    directory.mkdir(parents=True, exist_ok=True)
+    manifest = {"name": directory.resolve().name, "type": policy_type,
+                "checkpointDir": "./checkpoint", "volume": volume,
+                "runtimeImageId": runtime_image, "rateHz": rate_hz, "cycles": 5}
+    (directory / "mru.json").write_text(json.dumps(manifest, indent=2) + "\n")
+    (directory / "README.md").write_text(JOB_README)
+    (directory / ".gitignore").write_text("/checkpoint/\n.env\n.env.*\n.venv/\n__pycache__/\n.DS_Store\n")
+    (directory / "checkpoint").mkdir()
+    return directory.resolve()
+
+
+def load_project(source, checkpoint_override=None, *, target=None, task=None):
+    source = Path(source)
+    manifest_path = source / "mru.json" if source.is_dir() else source
+    raw = json.loads(manifest_path.read_text())
+    if not isinstance(raw, dict):
+        raise ValueError("Manifest must be a JSON object")
+    if target is not None:
+        if target == "local":
+            raw["inferenceTarget"] = "local"
+            raw.pop("volume", None)
+            raw.pop("runtimeImageId", None)
+        elif target == "modal":
+            raw.pop("inferenceTarget", None)
+            raw.pop("task", None)
+        else:
+            raise ValueError("Inference target must be modal or local")
+    if task is not None:
+        raw["task"] = task
+    relative = raw.pop("checkpointDir", None)
+    checkpoint = Path(checkpoint_override) if checkpoint_override is not None else None
+    if relative is not None and checkpoint is None:
+        if not isinstance(relative, str) or not relative.strip():
+            raise ValueError("checkpointDir must name a directory inside the job folder")
+        path = Path(relative)
+        if path.is_absolute() or ".." in path.parts or not path.parts:
+            raise ValueError("checkpointDir must name a directory inside the job folder")
+        root = manifest_path.parent.resolve()
+        checkpoint = root / path
+        if root not in checkpoint.resolve().parents or any(
+                (root / Path(*path.parts[:index])).is_symlink() for index in range(1, len(path.parts) + 1)):
+            raise ValueError("checkpointDir must stay inside the job folder without symlinks")
+    if checkpoint is not None:
+        digest = checkpoint_digest(checkpoint)
+        raw.update(checkpointDigest=digest, checkpoint="/store/mru/checkpoints/" + digest)
+    return validate_manifest(raw), checkpoint

mru_cli/targets.py

@@ -0,0 +1,106 @@
+"""Terminal access to the resident Devbox's fixed Ethernet inference target."""
+import http.client
+import ipaddress
+import json
+from contextlib import contextmanager
+from pathlib import Path
+import re
+import sys
+import time
+import tarfile
+import tempfile
+from urllib.parse import urlparse, quote
+from .manifest import checkpoint_digest
+
+
+DEFAULT_RELAY = "http://100.122.87.127:8092"
+
+
+class UploadStream:
+    def __init__(self, handle, total):
+        self.handle, self.total = handle, total
+        self.sent, self.last = 0, time.monotonic()
+
+    def read(self, size):
+        data = self.handle.read(size)
+        self.sent += len(data)
+        now = time.monotonic()
+        if now - self.last >= 15 or not data:
+            print(f"Uploaded {self.sent / 1024**3:.2f} / {self.total / 1024**3:.2f} GiB to Devbox", file=sys.stderr)
+            self.last = now
+        return data
+
+
+@contextmanager
+def packed_checkpoint(checkpoint):
+    with tempfile.TemporaryDirectory(prefix="mru-local-") as directory:
+        archive = Path(directory) / "checkpoint.tar"
+        print("Packing checkpoint for Ethernet upload…", file=sys.stderr)
+        with tarfile.open(archive, "w", dereference=False) as output:
+            output.add(checkpoint, arcname="pretrained_model")
+        print(f"Uploading {archive.stat().st_size / 1024**3:.2f} GiB through the Devbox…", file=sys.stderr)
+        yield archive
+
+
+def relay_origin(value):
+    parsed = urlparse(value)
+    try:
+        address = ipaddress.ip_address(parsed.hostname or "")
+        trusted_http = address.is_loopback or address in ipaddress.ip_network("100.64.0.0/10")
+    except ValueError:
+        trusted_http = parsed.hostname == "localhost"
+    if (not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment
+            or parsed.path not in ("", "/") or parsed.scheme not in {"https", "http"}
+            or parsed.scheme == "http" and not trusted_http):
+        raise ValueError("Use an HTTPS relay, or HTTP over Tailscale/localhost")
+    return value.rstrip("/")
+
+
+class LocalTarget:
+    def __init__(self, token, url=DEFAULT_RELAY):
+        self.url, self.token = relay_origin(url), token
+
+    def request(self, path, archive=None, body=None):
+        parsed = urlparse(self.url)
+        connection_type = http.client.HTTPSConnection if parsed.scheme == "https" else http.client.HTTPConnection
+        connection = connection_type(parsed.hostname, parsed.port, timeout=7200 if archive or body is not None else 30, blocksize=1024 * 1024)
+        try:
+            headers = {"Authorization": "Bearer " + self.token}
+            if archive:
+                headers.update({"Content-Type": "application/x-tar", "Content-Length": str(archive.stat().st_size)})
+                with archive.open("rb") as handle:
+                    connection.request("POST", path, body=UploadStream(handle, archive.stat().st_size), headers=headers)
+            else:
+                payload = json.dumps(body).encode() if body is not None else None
+                headers["Content-Type"] = "application/json"
+                connection.request("POST" if body is not None else "GET", path, body=payload, headers=headers)
+            response = connection.getresponse()
+            result = json.loads(response.read())
+            if response.status >= 400:
+                raise ValueError(result.get("detail", "Local inference request failed"))
+            return result
+        except (OSError, http.client.HTTPException) as error:
+            raise ValueError("Devbox inference relay unavailable. Inspect mru target status before retrying; publication may have been accepted.") from error
+        finally:
+            connection.close()
+
+    def publish(self, deployment, checkpoint, digest=None):
+        path = "/v1/deployments/" + quote(deployment, safe="") + "/publish"
+        if digest and self.request("/v1/staged/" + digest)["available"]:
+            print("Reusing the verified checkpoint already on the Ethernet box…", file=sys.stderr)
+            return self.request(path, body={"reuseStaged": True})
+        if checkpoint is None:
+            raise ValueError("Checkpoint is not staged; supply --checkpoint /path/to/pretrained_model")
+        with packed_checkpoint(checkpoint) as archive:
+            return self.request(path, archive)
+
+    def stage(self, checkpoint, name=None):
+        digest = checkpoint_digest(checkpoint)
+        name = name or "mru-" + digest[:24]
+        if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,63}", name):
+            raise ValueError("Model name must contain 1–64 letters, numbers, dots, hyphens or underscores")
+        with packed_checkpoint(checkpoint) as archive:
+            return self.request("/v1/stage?digest=" + digest + "&name=" + quote(name, safe=""), archive)
+
+    def pull(self, deployment, name=None):
+        return self.request("/v1/pull/" + quote(deployment, safe=""), body={"name": name} if name else {})

mru_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: mru-cli
+Version: 0.1.2
+Summary: Deploy pinned robot checkpoints and track MRU physical runs
+Project-URL: Repository, https://github.com/Druzrka/mru-cli
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: modal<2,>=1.0
+
+# MRU CLI
+
+The standalone command-line client for [Make Robots Useful](https://app.makerobotsuseful.com).
+It talks to the MRU API using your account token. Installation and login do not
+require a checkpoint, a robot connection, or a Modal account.
+
+## Install from this checkout
+
+Requires Python 3.11 or newer. Clone this repository, then run:
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install .
+.venv/bin/mru --help
+.venv/bin/mru --url https://app.makerobotsuseful.com login
+```
+
+Create an account token at [Connect](https://app.makerobotsuseful.com/#connect)
+and enter it in the hidden login prompt. Login verifies your identity through
+`/v1/me` and saves credentials with mode `0600` in `~/.config/mru/config.json`.
+Do not put tokens in chat, Git, or command arguments. `mru logout` removes the
+local credentials; revoke tokens in the dashboard.
+
+```bash
+mru --url https://app.makerobotsuseful.com --json deployments
+```
+
+Robot access is assigned by MRU separately. A new account can log in without
+being assigned a robot. Network restrictions in an agent's environment must
+permit the MRU API domain even when package installation succeeds.
+
+## Upload a trained checkpoint
+
+ACT (`act`) and pi0.5 (`pi05`) are supported checkpoint formats, not models
+included with an account. Use your own complete trained checkpoint, including
+weights, config, preprocessor and postprocessor. Cloud publication also needs
+the assigned Modal workspace/environment, an existing volume, and a validated
+runtime image. The control rate must match training.
+
+Use `mru init --help`, `mru check --help`, and `mru deploy --help` for project
+settings. `mru deploy ... --no-run` publishes and validates without queuing a
+physical trial. Running a trial requires explicit authorization; plain
+`mru deploy` also queues a run.
+
+`mru target` manages optional local inference through the commissioned Devbox
+relay. It is not required for CLI installation or login. The CLI itself does
+not contain the robot operator services.
+
+## Develop and test
+
+```bash
+.venv/bin/python -m pip install -e .
+.venv/bin/python -m unittest discover -s tests -v
+```
+
+The client manifest contract in `mru_cli/manifest.py` implements
+`mru.physical-deployment/v1`. Its server counterpart lives in
+`mru-web/backend/deployment_manifest.py`. Contract changes require compatibility
+tests on both sides; moving repositories does not change the wire protocol.
+
+## Build and publish
+
+Version 0.1.2 moves the inference wrapper into `mru_cli.modal_inference`, removing
+the dependency on the web repository's `integrations` namespace.
+
+```bash
+.venv/bin/python scripts/build_release.py
+shasum -a 256 releases/mru_cli-0.1.2-py3-none-any.whl
+```
+
+Review and commit the wheel together with its source. The manual
+`publish-cli.yml` workflow stages only the wheel matching the supplied SHA256.
+It runs only from `main`; pushing code does not publish a package.
+
+Before the first release from this repository, configure a PyPI trusted
+publisher for project `mru-cli`, owner `Druzrka`, repository `mru-cli`, workflow
+`publish-cli.yml`, environment `pypi`. Configure the GitHub `pypi` environment to
+allow only `main`. The previous publisher for `mru-web` does not authorize this
+repository. No PyPI release is performed as part of this extraction.
+
+This repository was extracted from `Druzrka/mru-web` commit
+`7bd1a908f8cb7ee993201462a452a7b4369c0897`. It contains only customer CLI code,
+its prediction-only inference wrapper, tests, and release tooling.

mru_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+mru_cli/__init__.py,sha256=YhaMTC9M8xkcHVrbI0-ixgfliHfe2tiDqXSOxf4uBMw,27
+mru_cli/__main__.py,sha256=EwrK-u-Eg2JchXI165ldrOFBIaW6EO7Cx0ZMnwRRU6c,49
+mru_cli/main.py,sha256=YiavBIGsiCckKs3Oopd23zjttYFF41GMUoODM5Vhjmk,21125
+mru_cli/manifest.py,sha256=rxVqFNoope-VNFdztFg6fH2qogR9wuUc-ed2z6WjoiI,4125
+mru_cli/modal_inference.py,sha256=6Rp013281Q0CSUaiZ0IGODOzI9oa_LhZGttGumtH4Bg,7046
+mru_cli/project.py,sha256=4PL3W2Ivood6RdSV5U01xaOkLO8OhPhc75D69Tco3P4,4600
+mru_cli/targets.py,sha256=CkA9ekhLxDeSAWXaP6AXzDet5i1gaIFLYVuXnZzrE20,4956
+mru_cli-0.1.2.dist-info/METADATA,sha256=sLL_baGeCX_Fgb1fgX0hKP_DGobyD78LM-D6DUzWYd0,3777
+mru_cli-0.1.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mru_cli-0.1.2.dist-info/entry_points.txt,sha256=zsi5UooB8s2XG-5sGUblO9zy9xq-CNM1ED1P1f4vs8M,42
+mru_cli-0.1.2.dist-info/top_level.txt,sha256=AScFE93QcEweyjCxy7S724GfkJSUPOnJ6nLvgbIeljg,8
+mru_cli-0.1.2.dist-info/RECORD,,

mru_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mru_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mru = mru_cli.main:main

mru_cli-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+mru_cli