Feat: Add Terms & Conditions

Author: philogicae

pyproject.toml

@@ -33,16 +33,16 @@ dynamic = [ "version" ]
 dependencies = [
   "aiodns==3.2",
   "aiohttp==3.10.6",
-  "aleph-message>=0.5",
+  "aleph-message @ git+https://github.com/aleph-im/aleph-message@aleph-323-terms-and-conditions",
   "aleph-sdk-python>=1.2,<2",
-  "base58==2.1.1",               # Needed now as default with _load_account changement
-  "py-sr25519-bindings==0.2",    # Needed for DOT signatures
+  "base58==2.1.1",                                                                                # Needed now as default with _load_account changement
+  "py-sr25519-bindings==0.2",                                                                     # Needed for DOT signatures
   "pygments==2.18",
-  "pynacl==1.5",                 # Needed now as default with _load_account changement
+  "pynacl==1.5",                                                                                  # Needed now as default with _load_account changement
   "python-magic==0.4.27",
   "rich==13.9.3",
   "setuptools>=65.5",
-  "substrate-interface==1.7.11", # Needed for DOT signatures
+  "substrate-interface==1.7.11",                                                                  # Needed for DOT signatures
   "textual==0.73",
   "typer==0.12.5",
 ]

scripts/gendoc.py

@@ -3,15 +3,16 @@
 Copied from typer.cli.py to customise doc generation
 """
 
-import click
 import importlib.util
 import re
 import sys
+from pathlib import Path
+from typing import Any, List, Optional
+
+import click
 import typer
 import typer.core
 from click import Command, Group
-from pathlib import Path
-from typing import Any, List, Optional
 
 default_app_names = ("app", "cli", "main")
 default_func_names = ("main", "cli", "app")

src/aleph_client/commands/files.py

@@ -11,8 +11,9 @@
 from aleph.sdk import AlephHttpClient, AuthenticatedAlephHttpClient
 from aleph.sdk.account import _load_account
 from aleph.sdk.conf import settings
+from aleph.sdk.exceptions import ForgottenMessageError, MessageNotFoundError
 from aleph.sdk.types import AccountFromPrivateKey, StorageEnum
-from aleph_message.models import ItemHash, StoreMessage
+from aleph_message.models import ItemHash, ItemType, MessageType, StoreMessage
 from aleph_message.status import MessageStatus
 from pydantic import BaseModel, Field
 from rich import box
@@ -241,3 +242,35 @@ async def list(
                 typer.echo(f"Failed to retrieve files for address {address}. Status code: {response.status}")
     else:
         typer.echo("Error: Please provide either a private key, private key file, or an address.")
+
+
+@app.command()
+async def ipfs_content(
+    item_hash: str = typer.Argument(..., help="Item hash of the store message"),
+    as_url: bool = True,
+    verbose: bool = True,
+) -> Optional[str]:
+    """Return the underlying ipfs content url for a given store message item hash"""
+
+    url, resp = None, None
+    async with AlephHttpClient(api_server=settings.API_HOST) as client:
+        try:
+            message, status = await client.get_message(item_hash=ItemHash(item_hash), with_status=True)
+            if status != MessageStatus.PROCESSED:
+                resp = f"Invalid message status: {status}"
+            elif message.type != MessageType.store:
+                resp = f"Invalid message type: {message.type}"
+            elif message.content.item_type != ItemType.ipfs:
+                resp = f"Invalid item type: {message.content.item_type}"
+            elif not message.content.item_hash:
+                resp = f"Invalid CID: {message.content.item_hash}"
+            else:
+                url = ("https://ipfs.aleph.cloud/ipfs/" if as_url else "") + message.content.item_hash
+                resp = f"IPFS Content {'URL' if as_url else 'CID'}: {url}"
+        except MessageNotFoundError:
+            resp = f"Message not found: {item_hash}"
+        except ForgottenMessageError:
+            resp = f"Message forgotten: {item_hash}"
+    if verbose:
+        typer.echo(resp)
+    return url

src/aleph_client/commands/instance/__init__.py

@@ -338,6 +338,7 @@ async def create(
                         confidential_computing=bool(
                             crn_info.get("computing", {}).get("ENABLE_CONFIDENTIAL_COMPUTING", False)
                         ),
+                        terms_and_conditions=crn_info.get("terms_and_conditions"),
                     )
                     echo("\n* Selected CRN *")
                     crn.display_crn_specs()
@@ -374,6 +375,16 @@ async def create(
             echo("Selected CRN does not support confidential computing.")
             raise typer.Exit(1)
 
+        if crn.terms_and_conditions:
+            accepted = await crn.display_terms_and_conditions
+            if accepted is None:
+                echo("Failed to fetch terms and conditions.\nContact support or use a different CRN.")
+                raise typer.Exit(1)
+            elif not accepted:
+                echo("Terms & Conditions rejected: instance creation aborted.")
+                raise typer.Exit(1)
+            echo("Terms & Conditions accepted.")
+
     async with AuthenticatedAlephHttpClient(account=account, api_server=settings.API_HOST) as client:
         payment = Payment(
             chain=payment_chain,
@@ -395,7 +406,18 @@ async def create(
                 ssh_keys=[ssh_pubkey],
                 hypervisor=hypervisor,
                 payment=payment,
-                requirements=HostRequirements(node=NodeRequirements(node_hash=crn.hash)) if crn else None,
+                requirements=(
+                    HostRequirements(
+                        node=NodeRequirements(
+                            node_hash=crn.hash,
+                            terms_and_conditions=(
+                                ItemHash(crn.terms_and_conditions) if crn.terms_and_conditions else None
+                            ),
+                        )
+                    )
+                    if crn
+                    else None
+                ),
                 trusted_execution=(
                     TrustedExecutionEnvironment(firmware=confidential_firmware_as_hash) if confidential else None
                 ),
@@ -642,7 +664,7 @@ async def _show_instances(messages: List[InstanceMessage], node_list: NodeInfo):
             chain_label, chain_color = "BASE", "blue3"
         elif chain_label == "SOL":
             chain_label, chain_color = "SOL ", "medium_spring_green"
-        else:  # ETH
+        elif len(chain_label) == 3:  # ETH
             chain_label += " "
         chain = Text.assemble("Chain: ", Text(chain_label, style=chain_color))
         created_at_parsed = str(str_to_datetime(str(info["created_at"]))).split(".")[0]
@@ -687,6 +709,36 @@ async def _show_instances(messages: List[InstanceMessage], node_list: NodeInfo):
                 Text(str(info["ipv6_logs"])),
                 style="bright_yellow" if len(str(info["ipv6_logs"]).split(":")) == 8 else "dark_orange",
             ),
+            (
+                Text.assemble(
+                    Text(
+                        f"\n[{'✅' if info['terms_and_conditions']['accepted'] else '❌'}] Signed latest Terms & Conditions:\n"
+                    ),
+                    Text(
+                        f"{info['terms_and_conditions']['url']}",
+                        style="orange1",
+                    ),
+                    (
+                        Text.assemble(
+                            Text(
+                                "\nReason:\n",
+                            ),
+                            Text(
+                                f"{info['terms_and_conditions']['info']['outdated']}\n",
+                                style="red",
+                            ),
+                            Text(
+                                f"≠ {info['terms_and_conditions']['info']['latest']}",
+                                style="green",
+                            ),
+                        )
+                        if info["terms_and_conditions"]["info"]
+                        else ""
+                    ),
+                )
+                if info["terms_and_conditions"]["hash"]
+                else ""
+            ),
         )
         table.add_row(instance, specifications, status_column)
         table.add_section()

src/aleph_client/commands/instance/display.py

@@ -62,6 +62,7 @@ def compose(self):
         self.table.add_column("Free RAM 🌡", key="ram")
         self.table.add_column("Free Disk 💿", key="hdd")
         self.table.add_column("URL", key="url")
+        self.table.add_column("Terms & Conditions 📝", key="tac")
         yield Label("Choose a Compute Resource Node (CRN) to run your instance")
         with Horizontal():
             self.loader_label_start = Label(self.label_start)
@@ -92,6 +93,7 @@ async def fetch_node_list(self):
                 machine_usage=None,
                 qemu_support=None,
                 confidential_computing=None,
+                terms_and_conditions=node.get("terms_and_conditions"),
             )
 
         # Initialize the progress bar
@@ -141,6 +143,9 @@ async def fetch_node_info(self, node: CRNInfo):
                 return
             self.filtered_crns += 1
 
+            # Fetch terms and conditions
+            tac = await node.link_terms_and_conditions if node.terms_and_conditions else "❌"
+
             self.table.add_row(
                 _format_score(node.score),
                 node.name,
@@ -152,6 +157,7 @@ async def fetch_node_info(self, node: CRNInfo):
                 node.display_ram,
                 node.display_hdd,
                 node.url,
+                tac,
                 key=node.hash,
             )
 

src/aleph_client/commands/instance/network.py

@@ -3,7 +3,7 @@
 import logging
 from ipaddress import IPv6Interface
 from json import JSONDecodeError
-from typing import Optional
+from typing import Any, Optional
 
 import aiohttp
 from aleph.sdk import AlephHttpClient
@@ -14,10 +14,11 @@
 from pydantic import ValidationError
 
 from aleph_client.commands import help_strings
+from aleph_client.commands.files import ipfs_content
 from aleph_client.commands.node import NodeInfo, _fetch_nodes
 from aleph_client.commands.utils import safe_getattr
 from aleph_client.models import MachineUsage
-from aleph_client.utils import AsyncTyper, fetch_json, sanitize_url
+from aleph_client.utils import fetch_json, sanitize_url
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +69,7 @@ async def fetch_crn_info(node_url: str) -> dict | None:
     return None
 
 
-async def fetch_vm_info(message: InstanceMessage, node_list: NodeInfo) -> tuple[str, dict[str, object]]:
+async def fetch_vm_info(message: InstanceMessage, node_list: NodeInfo) -> tuple[str, dict[str, Any]]:
     """
     Fetches VM information given an instance message and the node list.
 
@@ -93,6 +94,7 @@ async def fetch_vm_info(message: InstanceMessage, node_list: NodeInfo) -> tuple[
             allocation_type="",
             ipv6_logs="",
             crn_url="",
+            terms_and_conditions=dict(hash=None, url=None, accepted=False, info=None),
         )
         try:
             # Fetch from the scheduler API directly if no payment or no receiver (hold-tier non-confidential)
@@ -118,6 +120,30 @@ async def fetch_vm_info(message: InstanceMessage, node_list: NodeInfo) -> tuple[
                 for node in node_list.nodes:
                     if node["hash"] == safe_getattr(message, "content.requirements.node.node_hash"):
                         info["crn_url"] = node["address"].rstrip("/")
+
+                        # Terms and conditions
+                        if "terms_and_conditions" in node:
+                            latest_tac_hash = str(node["terms_and_conditions"])
+                            latest_tac_url = (
+                                await ipfs_content(latest_tac_hash, verbose=False) or f"missing → {latest_tac_hash}"
+                            )
+                            vm_tac_hash = safe_getattr(message, "content.requirements.node.terms_and_conditions")
+                            tac_accepted = vm_tac_hash and latest_tac_hash == str(vm_tac_hash)
+                            tac_info = None
+                            if not tac_accepted:
+                                vm_tac_url = (
+                                    (await ipfs_content(vm_tac_hash, verbose=False) or f"missing → {vm_tac_hash}")
+                                    if vm_tac_hash
+                                    else None
+                                )
+                                tac_info = dict(
+                                    outdated=f"Outdated: {vm_tac_hash}\nURL: {vm_tac_url}",
+                                    latest=f"Latest: {latest_tac_hash}\nURL: {latest_tac_url}",
+                                )
+                            info["terms_and_conditions"] = dict(
+                                hash=latest_tac_hash, url=latest_tac_url, accepted=tac_accepted, info=tac_info
+                            )
+
                         path = f"{node['address'].rstrip('/')}/about/executions/list"
                         executions = await fetch_json(session, path)
                         if message.item_hash in executions:

src/aleph_client/models.py

@@ -4,8 +4,10 @@
 from aleph_message.models import ItemHash
 from aleph_message.models.execution.environment import CpuProperties
 from pydantic import BaseModel
+from rich.prompt import Prompt
 from typer import echo
 
+from aleph_client.commands.files import ipfs_content
 from aleph_client.commands.node import _escape_and_normalize, _remove_ansi_escape
 
 
@@ -114,6 +116,7 @@ class CRNInfo(BaseModel):
     machine_usage: Optional[MachineUsage]
     qemu_support: Optional[bool]
     confidential_computing: Optional[bool]
+    terms_and_conditions: Optional[str]
 
     @property
     def display_cpu(self) -> str:
@@ -133,6 +136,23 @@ def display_hdd(self) -> str:
             return f"{self.machine_usage.disk.available_kB / 1_000_000:>4.0f} / {self.machine_usage.disk.total_kB / 1_000_000:>4.0f} GB"
         return ""
 
+    @property
+    async def link_terms_and_conditions(self) -> Optional[str]:
+        if self.terms_and_conditions:
+            return await ipfs_content(self.terms_and_conditions, verbose=False)
+        return None
+
+    @property
+    async def display_terms_and_conditions(self) -> Optional[bool]:
+        if self.terms_and_conditions:
+            url = await self.link_terms_and_conditions
+            echo("* Terms & Conditions *")
+            if url:
+                echo("The selected CRN requires you to accept the following conditions and terms of use:\n")
+                echo(f"→ {url}\n")
+                return Prompt.ask("To proceed, enter “Yes I read and accept”").lower() == "yes i read and accept"
+        return None
+
     def display_crn_specs(self):
         echo(f"Hash: {self.hash}")
         echo(f"Name: {self.name}")
@@ -146,3 +166,5 @@ def display_crn_specs(self):
             echo(f"Available Disk: {self.display_hdd}")
         echo(f"Support Qemu: {self.qemu_support}")
         echo(f"Support Confidential: {self.confidential_computing}")
+        if self.terms_and_conditions:
+            echo(f"Terms & Conditions: {self.terms_and_conditions}")

tests/unit/conftest.py

@@ -8,7 +8,7 @@
 """
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import Generator
+from typing import Generator, Tuple
 
 import pytest
 from aleph.sdk.chains.common import generate_key
@@ -27,7 +27,7 @@ def empty_account_file() -> Generator[Path, None, None]:
 
 
 @pytest.fixture
-def env_files(new_config_file: Path, empty_account_file: Path) -> Generator[Path, None, None]:
+def env_files(new_config_file: Path, empty_account_file: Path) -> Generator[Tuple[Path, Path], None, None]:
     new_config_file.write_text(f'{{"path": "{empty_account_file}", "chain": "ETH"}}')
     empty_account_file.write_bytes(generate_key())
     yield empty_account_file, new_config_file

tests/unit/test_commands.py

@@ -293,3 +293,17 @@ def test_file_download():
     )
     assert result.exit_code == 0
     assert result.stdout is not None
+
+
+def test_ipfs_content():
+    # Test retrieve the underlying ipfs content url
+    result = runner.invoke(
+        app,
+        [
+            "file",
+            "ipfs-content",
+            "2f50b6d078005074801260bac1f8860b10d2a92cf00c91459800ea6042a02cc9",
+        ],
+    )
+    assert result.exit_code == 0
+    assert result.stdout is not None