Feat: Add T&C (rebased)

Author: philogicae

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,21 +11,24 @@
 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
 from rich.console import Console
 from rich.table import Table
 
 from aleph_client.commands import help_strings
-from aleph_client.commands.utils import setup_logging
+from aleph_client.commands.utils import safe_getattr, setup_logging
 from aleph_client.utils import AsyncTyper
 
 logger = logging.getLogger(__name__)
 app = AsyncTyper(no_args_is_help=True)
 
+IPFS_GATEWAY = "https://ipfs.aleph.cloud/ipfs/"
+
 
 @app.command()
 async def pin(
@@ -241,3 +244,43 @@ 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.")
+
+
+class IpfsContent(BaseModel):
+    filename: Optional[str]
+    cid: str
+    url: str
+
+
+@app.command()
+async def ipfs_content(
+    item_hash: str = typer.Argument(..., help="Item hash of the store message"),
+    verbose: bool = True,
+) -> Optional[IpfsContent]:
+    """Return the underlying ipfs content for a given store message item hash"""
+
+    result, 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:
+                filename = message.content.metadata.name if safe_getattr(message.content, "metadata.name") else ""
+                cid = message.content.item_hash
+                url = f"{IPFS_GATEWAY}{cid}"
+                result = IpfsContent(filename=filename, cid=cid, url=url)
+                resp = f"Filename: {filename or 'None'}\nCID: {cid}\nURL: {url}"
+        except MessageNotFoundError:
+            resp = f"Message not found: {item_hash}"
+        except ForgottenMessageError:
+            resp = f"Message forgotten: {item_hash}"
+    if verbose:
+        typer.echo(resp)
+    return result

src/aleph_client/commands/help_strings.py

@@ -35,6 +35,7 @@
 SSH_PUBKEY_FILE = "Path to a public ssh key to be added to the instance"
 CRN_HASH = "Hash of the CRN to deploy to (only applicable for confidential and/or Pay-As-You-Go instances)"
 CRN_URL = "URL of the CRN to deploy to (only applicable for confidential and/or Pay-As-You-Go instances)"
+CRN_AUTO_TAC = "Automatically accept the Terms & Conditions of the CRN if you read them beforehand"
 CONFIDENTIAL_OPTION = "Launch a confidential instance (requires creating an encrypted volume)"
 CONFIDENTIAL_FIRMWARE = "Hash to UEFI Firmware to launch confidential instance"
 CONFIDENTIAL_FIRMWARE_HASH = "Hash of the UEFI Firmware content, to validate measure (ignored if path is provided)"

src/aleph_client/commands/instance/__init__.py

@@ -27,25 +27,6 @@
 from aleph.sdk.query.responses import PriceResponse
 from aleph.sdk.types import StorageEnum
 from aleph.sdk.utils import calculate_firmware_hash
-from aleph_message.models import InstanceMessage, StoreMessage
-from aleph_message.models.base import Chain, MessageType
-from aleph_message.models.execution.base import Payment, PaymentType
-from aleph_message.models.execution.environment import (
-    GpuDeviceClass,
-    GpuProperties,
-    HostRequirements,
-    HypervisorType,
-    NodeRequirements,
-    TrustedExecutionEnvironment,
-)
-from aleph_message.models.item_hash import ItemHash
-from click import echo
-from rich import box
-from rich.console import Console
-from rich.prompt import Confirm, Prompt
-from rich.table import Table
-from rich.text import Text
-
 from aleph_client.commands import help_strings
 from aleph_client.commands.instance.display import CRNTable
 from aleph_client.commands.instance.network import (
@@ -69,6 +50,24 @@
 )
 from aleph_client.models import CRNInfo
 from aleph_client.utils import AsyncTyper, sanitize_url
+from aleph_message.models import InstanceMessage, StoreMessage
+from aleph_message.models.base import Chain, MessageType
+from aleph_message.models.execution.base import Payment, PaymentType
+from aleph_message.models.execution.environment import (
+    GpuDeviceClass,
+    GpuProperties,
+    HostRequirements,
+    HypervisorType,
+    NodeRequirements,
+    TrustedExecutionEnvironment,
+)
+from aleph_message.models.item_hash import ItemHash
+from click import echo
+from rich import box
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich.text import Text
 
 logger = logging.getLogger(__name__)
 app = AsyncTyper(no_args_is_help=True)
@@ -117,6 +116,7 @@ async def create(
         None,
         help=help_strings.IMMUTABLE_VOLUME,
     ),
+    crn_auto_tac: bool = typer.Option(False, help=help_strings.CRN_AUTO_TAC),
     channel: Optional[str] = typer.Option(default=settings.DEFAULT_CHANNEL, help=help_strings.CHANNEL),
     private_key: Optional[str] = typer.Option(settings.PRIVATE_KEY_STRING, help=help_strings.PRIVATE_KEY),
     private_key_file: Optional[Path] = typer.Option(settings.PRIVATE_KEY_FILE, help=help_strings.PRIVATE_KEY_FILE),
@@ -342,6 +342,7 @@ async def create(
                             crn_info.get("computing", {}).get("ENABLE_CONFIDENTIAL_COMPUTING", False)
                         ),
                         gpu_support=bool(crn_info.get("computing", {}).get("ENABLE_GPU_SUPPORT", False)),
+                        terms_and_conditions=crn_info.get("terms_and_conditions"),
                     )
                     echo("\n* Selected CRN *")
                     crn.display_crn_specs()
@@ -409,6 +410,15 @@ async def create(
                         device_id=selected_gpu.device_id,
                     )
                 ]
+        if crn.terms_and_conditions:
+            accepted = await crn.display_terms_and_conditions(auto_accept=crn_auto_tac)
+            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(
@@ -433,7 +443,12 @@ async def create(
                 payment=payment,
                 requirements=(
                     HostRequirements(
-                        node=NodeRequirements(node_hash=crn.hash),
+                        node=NodeRequirements(
+                            node_hash=crn.hash,
+                            terms_and_conditions=(
+                                ItemHash(crn.terms_and_conditions) if crn.terms_and_conditions else None
+                            ),
+                        ),
                         gpu=gpu_requirement,
                     )
                     if crn
@@ -685,7 +700,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]
@@ -730,6 +745,19 @@ 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 '❌'}] Accepted Terms & Conditions:\n"
+                    ),
+                    Text(
+                        f"{info['terms_and_conditions']['url']}",
+                        style="orange1",
+                    ),
+                )
+                if info["terms_and_conditions"]["hash"]
+                else ""
+            ),
         )
         table.add_row(instance, specifications, status_column)
         table.add_section()
@@ -1192,6 +1220,7 @@ async def confidential_create(
         None,
         help=help_strings.IMMUTABLE_VOLUME,
     ),
+    crn_auto_tac: bool = typer.Option(False, help=help_strings.CRN_AUTO_TAC),
     channel: Optional[str] = typer.Option(default=settings.DEFAULT_CHANNEL, help=help_strings.CHANNEL),
     private_key: Optional[str] = typer.Option(settings.PRIVATE_KEY_STRING, help=help_strings.PRIVATE_KEY),
     private_key_file: Optional[Path] = typer.Option(settings.PRIVATE_KEY_FILE, help=help_strings.PRIVATE_KEY_FILE),
@@ -1223,6 +1252,7 @@ async def confidential_create(
             ssh_pubkey_file=ssh_pubkey_file,
             crn_hash=crn_hash,
             crn_url=crn_url,
+            crn_auto_tac=crn_auto_tac,
             confidential=True,
             confidential_firmware=confidential_firmware,
             skip_volume=skip_volume,

src/aleph_client/commands/instance/display.py

@@ -70,6 +70,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)
@@ -101,6 +102,7 @@ async def fetch_node_list(self):
                 qemu_support=None,
                 confidential_computing=None,
                 gpu_support=None,
+                terms_and_conditions=node.get("terms_and_conditions"),
             )
 
         # Initialize the progress bar
@@ -154,6 +156,9 @@ async def fetch_node_info(self, node: CRNInfo):
                 return
             self.filtered_crns += 1
 
+            # Fetch terms and conditions
+            tac = await node.terms_and_conditions_content
+
             self.table.add_row(
                 _format_score(node.score),
                 node.name,
@@ -166,6 +171,7 @@ async def fetch_node_info(self, node: CRNInfo):
                 node.display_ram,
                 node.display_hdd,
                 node.url,
+                tac.url if tac else "✖",
                 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),
         )
         try:
             # Fetch from the scheduler API directly if no payment or no receiver (hold-tier non-confidential)
@@ -118,6 +120,14 @@ 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
+                        tac_item_hash = safe_getattr(message, "content.requirements.node.terms_and_conditions")
+                        if tac_item_hash:
+                            tac = await ipfs_content(tac_item_hash, verbose=False)
+                            tac_url = (tac and tac.url) or f"missing → {tac_item_hash}"
+                            info["terms_and_conditions"] = dict(hash=tac_item_hash, url=tac_url, accepted=True)
+
                         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

@@ -5,8 +5,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 IpfsContent, ipfs_content
 from aleph_client.commands.node import _escape_and_normalize, _remove_ansi_escape
 
 
@@ -130,6 +132,7 @@ class CRNInfo(BaseModel):
     qemu_support: Optional[bool]
     confidential_computing: Optional[bool]
     gpu_support: Optional[bool]
+    terms_and_conditions: Optional[str]
 
     @property
     def display_cpu(self) -> str:
@@ -149,6 +152,27 @@ 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 terms_and_conditions_content(self) -> Optional[IpfsContent]:
+        if self.terms_and_conditions:
+            return await ipfs_content(self.terms_and_conditions, verbose=False)
+        return None
+
+    async def display_terms_and_conditions(self, auto_accept: bool = False) -> Optional[bool]:
+        if self.terms_and_conditions:
+            tac = await self.terms_and_conditions_content
+            echo("* Terms & Conditions *")
+            if tac:
+                echo("The selected CRN requires you to accept the following conditions and terms of use:\n")
+                if tac.filename:
+                    echo(f"Filename: {tac.filename}")
+                echo(f"↳ {tac.url}\n")
+                if auto_accept:
+                    echo("To proceed, enter “Yes I read and accept”: Yes I read and accept")
+                    return True
+                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}")
@@ -163,3 +187,5 @@ def display_crn_specs(self):
         echo(f"Support Qemu: {self.qemu_support}")
         echo(f"Support Confidential: {self.confidential_computing}")
         echo(f"Support GPU: {self.gpu_support}")
+        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