@le-space/rootfs 0.3.32 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/rootfs",
-  "version": "0.3.32",
+  "version": "0.4.0",
   "description": "Shared rootfs contract parsing, reference profile assets, and build helpers.",
   "license": "MIT",
   "type": "module",

package/reference/orbitdb-relay-pinner/rootfs/orbitdb-relay-pinner-bootstrap-refresh.py

@@ -306,22 +306,19 @@ def sign_aleph_message(unsigned_message: dict[str, object], private_key: str) ->
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, dict]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    request_body = {"sync": True, "message": message}
-    max_attempts = 3
+    attempts = [
+        {"sync": True, "message": message},
+        {**message, "sync": True},
+        dict(message),
+    ]
     last: tuple[int, dict] | None = None
-    for index in range(max_attempts):
-        last = post_json(url, request_body)
+    for attempt in attempts:
+        last = post_json(url, attempt)
         if 200 <= last[0] < 300:
             return last
-        publication_status = last[1].get("publication_status") if isinstance(last[1], dict) else None
-        retryable = last[0] >= 500 or (
-            isinstance(publication_status, dict)
-            and isinstance(publication_status.get("status"), str)
-            and publication_status.get("status").strip().lower() == "error"
-        )
-        if index >= max_attempts - 1 or not retryable:
-            raise RuntimeError(f"Aleph broadcast failed: {last[0]} {json_dumps(last[1])}")
-    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
+    if last is None:
+        raise RuntimeError("Aleph broadcast failed before any attempt was made")
+    raise RuntimeError(f"Aleph broadcast failed: {last[0]} {json_dumps(last[1])}")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap-deregister.py

@@ -155,16 +155,22 @@ def is_retryable_broadcast_failure(http_status: int, payload: object) -> bool:
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    request_body = {"sync": True, "message": message}
-    max_attempts = 3
-    for index in range(max_attempts):
-        http_status, payload = post_json(url, request_body)
+    attempts = [
+        {"sync": True, "message": message},
+        {**message, "sync": True},
+        dict(message),
+    ]
+    for index, attempt in enumerate(attempts):
+        http_status, payload = post_json(url, attempt)
         if 200 <= http_status < 300:
             return http_status, payload
-        can_retry = index < max_attempts - 1 and is_retryable_broadcast_failure(http_status, payload)
+        can_retry = index < len(attempts) - 1 and (
+            is_invalid_message_format(http_status, payload)
+            or is_retryable_broadcast_failure(http_status, payload)
+        )
         if not can_retry:
             raise RuntimeError(f"Aleph broadcast failed: {http_status} {json_dumps(payload)}")
-    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
+    raise RuntimeError("Aleph broadcast failed: no compatible request format was accepted")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap-refresh.py

@@ -246,13 +246,13 @@ def build_post_content(
     owner_authorization: dict[str, object] | None,
     relay_proof: dict[str, object],
     now_ms: int,
-    now_seconds: float,
     ref: str,
     post_type: str,
 ) -> dict[str, object]:
     content = {
         "peerId": peer_id,
         "multiaddrs": multiaddrs,
+        "browserMultiaddrs": browser_multiaddrs if browser_multiaddrs else None,
         "registrationId": registration_id,
         "profile": profile,
         "version": version,
@@ -266,14 +266,12 @@ def build_post_content(
         "relayProof": relay_proof,
         "updatedAt": now_ms,
     }
-    if browser_multiaddrs:
-        content["browserMultiaddrs"] = browser_multiaddrs
     return {
         "type": post_type,
         "address": sender,
         "ref": ref,
         "content": content,
-        "time": now_seconds,
+        "time": now_ms,
     }
 
 
@@ -349,16 +347,22 @@ def is_retryable_broadcast_failure(http_status: int, payload: object) -> bool:
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    request_body = {"sync": True, "message": message}
-    max_attempts = 3
-    for index in range(max_attempts):
-        http_status, payload = post_json(url, request_body)
+    attempts = [
+        {"sync": True, "message": message},
+        {**message, "sync": True},
+        dict(message),
+    ]
+    for index, attempt in enumerate(attempts):
+        http_status, payload = post_json(url, attempt)
         if 200 <= http_status < 300:
             return http_status, payload
-        can_retry = index < max_attempts - 1 and is_retryable_broadcast_failure(http_status, payload)
+        can_retry = index < len(attempts) - 1 and (
+            is_invalid_message_format(http_status, payload)
+            or is_retryable_broadcast_failure(http_status, payload)
+        )
         if not can_retry:
             raise RuntimeError(f"Aleph broadcast failed: {http_status} {json_dumps(payload)}")
-    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
+    raise RuntimeError("Aleph broadcast failed: no compatible request format was accepted")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:
@@ -534,7 +538,6 @@ def main() -> None:
         owner_authorization,
         relay_proof,
         now_ms,
-        now_seconds,
         ref,
         post_type,
     )

package/reference/uc-go-peer/rootfs/uc-go-peer-setup-server.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python3
-import base64
-import hashlib
 import ipaddress
 import json
 import os
@@ -9,8 +7,6 @@ import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from urllib import error as urllib_error
-from urllib import request as urllib_request
 from urllib.error import HTTPError, URLError
 from urllib.parse import urlencode, urlsplit
 from urllib.request import urlopen
@@ -27,36 +23,12 @@ AUTHORIZED_KEYS_FILE = os.environ.get("AUTHORIZED_KEYS_FILE", "/root/.ssh/author
 ALEPH_API_HOST = os.environ.get("ALEPH_API_HOST", "https://api2.aleph.im")
 BOOTSTRAP_CONFIG_KEY = os.environ.get("BOOTSTRAP_CONFIG_KEY", "vm-bootstrap-config")
 BOOTSTRAP_CONFIG_POLL_SECONDS = float(os.environ.get("BOOTSTRAP_CONFIG_POLL_SECONDS", "5"))
-BOOTSTRAP_CONFIG_SIGNAL_REF = os.environ.get("BOOTSTRAP_CONFIG_SIGNAL_REF", "vm-bootstrap-config")
-BOOTSTRAP_CONFIG_SIGNAL_POST_TYPE = os.environ.get(
-    "BOOTSTRAP_CONFIG_SIGNAL_POST_TYPE", "vm-bootstrap-config-status"
-)
-BOOTSTRAP_CHANNEL = os.environ.get("ALEPH_BOOTSTRAP_CHANNEL", "simple-todo")
 DESCRIBE_TIMEOUT_SECONDS = int(os.environ.get("DESCRIBE_TIMEOUT_SECONDS", "15"))
 DESCRIBE_INTERVAL_SECONDS = float(os.environ.get("DESCRIBE_INTERVAL_SECONDS", "1"))
 
 CONFIGURE_LOCK = threading.Lock()
 
 
-def _json_dumps(payload: object) -> str:
-    return json.dumps(payload, separators=(",", ":"))
-
-
-def _parse_env_file(path: str) -> dict[str, str]:
-    values: dict[str, str] = {}
-    if not os.path.exists(path):
-        return values
-
-    with open(path, encoding="utf-8") as handle:
-        for line in handle:
-            stripped = line.strip()
-            if not stripped or stripped.startswith("#") or "=" not in stripped:
-                continue
-            key, value = stripped.split("=", 1)
-            values[key.strip()] = value.strip()
-    return values
-
-
 def _cors_headers(handler: BaseHTTPRequestHandler) -> None:
     handler.send_header("Access-Control-Allow-Origin", "*")
     handler.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
@@ -171,7 +143,7 @@ def _build_configure_args(record: dict) -> list[str]:
     return args
 
 
-def _run_configure_process(args: list[str], bootstrap_record: dict | None = None) -> tuple[bool, str]:
+def _run_configure_process(args: list[str]) -> tuple[bool, str]:
     with CONFIGURE_LOCK:
         if os.path.exists(READY_FILE):
             return True, "ready"
@@ -181,223 +153,9 @@ def _run_configure_process(args: list[str], bootstrap_record: dict | None = None
             return False, error.stderr.strip() or error.stdout.strip() or str(error)
 
         _start_metadata_generation()
-        if isinstance(bootstrap_record, dict):
-            try:
-                _publish_vm_bootstrap_config_signal(bootstrap_record)
-            except Exception as error:  # pragma: no cover - runtime error path
-                return False, f"configured relay but failed to publish bootstrap config signal: {error}"
         return True, result.stdout.strip()
 
 
-def _address_from_private_key(private_key: str) -> str:
-    try:
-        from eth_account import Account
-    except ImportError as error:  # pragma: no cover - runtime dependency
-        raise RuntimeError(
-            "eth-account is required for guest-side bootstrap status publishing"
-        ) from error
-
-    return Account.from_key(private_key).address
-
-
-def _sign_personal_message(private_key: str, payload: str) -> str:
-    try:
-        from eth_account import Account
-        from eth_account.messages import encode_defunct
-    except ImportError as error:  # pragma: no cover - runtime dependency
-        raise RuntimeError(
-            "eth-account is required for guest-side bootstrap status publishing"
-        ) from error
-
-    message = encode_defunct(text=payload)
-    signed = Account.sign_message(message, private_key=private_key)
-    signature = signed.signature.hex()
-    return signature if signature.startswith("0x") else f"0x{signature}"
-
-
-def _signature_payload(chain: str, sender: str, message_type: str, item_hash: str) -> str:
-    return "\n".join([chain, sender, message_type, item_hash])
-
-
-def _iter_validation_errors(payload: object) -> list[dict]:
-    if isinstance(payload, list):
-        return [entry for entry in payload if isinstance(entry, dict)]
-    return []
-
-
-def _is_invalid_message_format(http_status: int, payload: object) -> bool:
-    if http_status != 422:
-        return False
-
-    if isinstance(payload, dict):
-        details = payload.get("details")
-        if isinstance(details, str) and "InvalidMessageFormat" in details:
-            return True
-        if isinstance(details, dict):
-            message = details.get("message")
-            if isinstance(message, str) and "InvalidMessageFormat" in message:
-                return True
-
-    for entry in _iter_validation_errors(payload):
-        message = entry.get("msg")
-        location = entry.get("loc")
-        if isinstance(message, str) and "InvalidMessageFormat" in message:
-            return True
-        if message == "Field required" and location == ["message"]:
-            return True
-
-    return False
-
-
-def _is_retryable_broadcast_failure(http_status: int, payload: object) -> bool:
-    if http_status >= 500:
-        return True
-    if isinstance(payload, dict):
-        publication_status = payload.get("publication_status")
-        if isinstance(publication_status, dict):
-            status = publication_status.get("status")
-            if isinstance(status, str) and status.strip().lower() == "error":
-                return True
-    return False
-
-
-def _post_json(url: str, body: dict[str, object]) -> tuple[int, object]:
-    data = _json_dumps(body).encode("utf-8")
-    request = urllib_request.Request(
-        url,
-        data=data,
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib_request.urlopen(request, timeout=30) as response:
-            payload = response.read().decode("utf-8")
-            return response.status, json.loads(payload or "{}")
-    except urllib_error.HTTPError as error:
-        payload = error.read().decode("utf-8")
-        try:
-            return error.code, json.loads(payload or "{}")
-        except json.JSONDecodeError:
-            return error.code, {"details": payload}
-
-
-def _broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
-    url = f"{api_host.rstrip('/')}/api/v0/messages"
-    request_body = {"sync": True, "message": message}
-    max_attempts = 3
-    for index in range(max_attempts):
-        http_status, payload = _post_json(url, request_body)
-        if 200 <= http_status < 300:
-            return http_status, payload
-        can_retry = index < max_attempts - 1 and _is_retryable_broadcast_failure(http_status, payload)
-        if not can_retry:
-            raise RuntimeError(
-                f"Aleph bootstrap status broadcast failed: {http_status} {_json_dumps(payload)}"
-            )
-    raise RuntimeError("Aleph bootstrap status broadcast failed: retry budget exhausted")
-
-
-def _publish_vm_bootstrap_config_signal(record: dict) -> None:
-    env_values = _parse_env_file(ENV_FILE)
-    publisher_private_key = env_values.get("ALEPH_BOOTSTRAP_PUBLISHER_PRIVATE_KEY", "").strip()
-    if not publisher_private_key:
-        raise RuntimeError("missing ALEPH_BOOTSTRAP_PUBLISHER_PRIVATE_KEY")
-
-    owner_authorization_b64 = env_values.get("ALEPH_BOOTSTRAP_OWNER_AUTHORIZATION_B64", "").strip()
-    owner_authorization = None
-    if owner_authorization_b64:
-        decoded = base64.b64decode(owner_authorization_b64).decode("utf-8")
-        parsed = json.loads(decoded)
-        if isinstance(parsed, dict):
-            owner_authorization = parsed
-
-    owner_address = ""
-    if isinstance(owner_authorization, dict):
-        payload = owner_authorization.get("payload")
-        if isinstance(payload, dict):
-            owner_address = str(payload.get("ownerAddress") or "").strip()
-    if not owner_address:
-        owner_address = str(record.get("ownerAddress") or "").strip()
-    if not owner_address:
-        raise RuntimeError("missing ownerAddress for bootstrap config signal")
-
-    deployment_token = str(record.get("deploymentToken") or "").strip()
-    profile = str(record.get("profile") or "").strip()
-    instance_item_hash = str(record.get("instanceItemHash") or "").strip()
-    if not deployment_token or not profile or not instance_item_hash:
-        raise RuntimeError("bootstrap config signal is missing deployment metadata")
-
-    metadata, metadata_error = _fresh_metadata_payload()
-    if not metadata:
-        raise RuntimeError(
-            f"bootstrap config signal metadata is not ready: {metadata_error or 'metadata unavailable'}"
-        )
-
-    peer_id = metadata.get("peer_id")
-    probe_multiaddrs = metadata.get("probe_multiaddrs")
-    browser_bootstrap_multiaddrs = metadata.get("browser_bootstrap_multiaddrs")
-    if not isinstance(peer_id, str) or not peer_id.strip():
-        raise RuntimeError("bootstrap config signal is missing peer_id")
-    if not isinstance(probe_multiaddrs, list) or not any(
-        isinstance(entry, str) and entry.strip() for entry in probe_multiaddrs
-    ):
-        raise RuntimeError("bootstrap config signal is missing probe_multiaddrs")
-    if not isinstance(browser_bootstrap_multiaddrs, list):
-        browser_bootstrap_multiaddrs = []
-
-    publisher_address = _address_from_private_key(publisher_private_key)
-    now_ms = int(time.time() * 1000)
-    content = {
-        "type": BOOTSTRAP_CONFIG_SIGNAL_POST_TYPE,
-        "address": publisher_address,
-        "ref": BOOTSTRAP_CONFIG_SIGNAL_REF,
-        "content": {
-            "deploymentToken": deployment_token,
-            "status": "applied",
-            "profile": profile,
-            "ownerAddress": owner_address,
-            "instanceItemHash": instance_item_hash,
-            "updatedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now_ms / 1000)),
-            "publisherAddress": publisher_address,
-            "authorization": owner_authorization,
-            "peerId": peer_id.strip(),
-            "probeMultiaddrs": [
-                entry.strip()
-                for entry in probe_multiaddrs
-                if isinstance(entry, str) and entry.strip()
-            ],
-            "browserBootstrapMultiaddrs": [
-                entry.strip()
-                for entry in browser_bootstrap_multiaddrs
-                if isinstance(entry, str) and entry.strip()
-            ],
-        },
-        "time": now_ms,
-    }
-    item_content = _json_dumps(content)
-    unsigned_message = {
-        "channel": BOOTSTRAP_CHANNEL,
-        "sender": publisher_address,
-        "chain": "ETH",
-        "type": "POST",
-        "time": now_ms / 1000,
-        "item_type": "inline",
-        "item_content": item_content,
-        "item_hash": hashlib.sha256(item_content.encode("utf-8")).hexdigest(),
-    }
-    signed_message = dict(unsigned_message)
-    signed_message["signature"] = _sign_personal_message(
-        publisher_private_key,
-        _signature_payload(
-            str(unsigned_message["chain"]),
-            str(unsigned_message["sender"]),
-            str(unsigned_message["type"]),
-            str(unsigned_message["item_hash"]),
-        ),
-    )
-    _broadcast_aleph_message(ALEPH_API_HOST, signed_message)
-
-
 def _load_vm_bootstrap_record() -> tuple[str | None, str | None, dict | None]:
     owner_address, deployment_token = _extract_guest_bootstrap_locator()
     if not owner_address or not deployment_token:
@@ -439,7 +197,7 @@ def _poll_bootstrap_config_loop() -> None:
             except ValueError:
                 time.sleep(BOOTSTRAP_CONFIG_POLL_SECONDS)
                 continue
-            ok, _ = _run_configure_process(args, record)
+            ok, _ = _run_configure_process(args)
             if ok:
                 return
         time.sleep(BOOTSTRAP_CONFIG_POLL_SECONDS)