hippius 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

hippius_sdk/cli_handlers.py

@@ -9,12 +9,11 @@ import asyncio
 import base64
 import getpass
 import json
+import math
 import os
-import pprint
-import sys
 import tempfile
 import time
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, List, Optional
 
 from hippius_sdk import (
     HippiusClient,
@@ -26,8 +25,6 @@ from hippius_sdk import (
     get_active_account,
     get_all_config,
     get_config_value,
-    get_seed_phrase,
-    initialize_from_env,
     list_accounts,
     load_config,
     reset_config,
@@ -48,6 +45,12 @@ from hippius_sdk.cli_rich import (
     success,
     warning,
 )
+from hippius_sdk.errors import (
+    HippiusAlreadyDeletedError,
+    HippiusFailedIPFSUnpin,
+    HippiusFailedSubstrateDelete,
+    HippiusMetadataError,
+)
 
 try:
     import nacl.secret
@@ -98,6 +101,21 @@ def create_client(args: Any) -> HippiusClient:
     # Get substrate URL
     substrate_url = args.substrate_url if hasattr(args, "substrate_url") else None
 
+    # Skip password if we're doing erasure-code with --no-publish
+    # This avoids prompting for password when we don't need to interact with the blockchain
+    password = None
+    if (
+        hasattr(args, "command")
+        and args.command == "erasure-code"
+        and hasattr(args, "no_publish")
+        and args.no_publish
+    ):
+        # Don't need a password in this case
+        password = None
+    else:
+        # Use password from args if provided
+        password = args.password if hasattr(args, "password") else None
+
     # Initialize client with provided parameters
     client = HippiusClient(
         ipfs_gateway=gateway,
@@ -106,7 +124,7 @@ def create_client(args: Any) -> HippiusClient:
         substrate_seed_phrase=(
             args.seed_phrase if hasattr(args, "seed_phrase") else None
         ),
-        seed_phrase_password=args.password if hasattr(args, "password") else None,
+        seed_phrase_password=password,
         account_name=args.account if hasattr(args, "account") else None,
         encrypt_by_default=encrypt,
         encryption_key=encryption_key,
@@ -136,6 +154,12 @@ async def handle_download(
         f"Size: [bold cyan]{result['size_bytes']:,}[/bold cyan] bytes ([bold cyan]{result['size_formatted']}[/bold cyan])",
     ]
 
+    # Add details about content type
+    if result.get("is_directory", False):
+        details.append("[bold green]Content type: Directory[/bold green]")
+    else:
+        details.append("[bold blue]Content type: File[/bold blue]")
+
     if result.get("decrypted"):
         details.append("[bold yellow]File was decrypted during download[/bold yellow]")
 
@@ -160,7 +184,7 @@ async def handle_exists(client: HippiusClient, cid: str) -> int:
             log(f"Gateway URL: [link]{result['gateway_url']}[/link]")
 
             # Display download command in a panel
-            command = f"hippius download {formatted_cid} <output_path>"
+            command = f"[bold green underline]hippius download {formatted_cid} <output_path>[/bold green underline]"
             print_panel(command, title="Download Command")
     else:
         error(f"CID [bold cyan]{formatted_cid}[/bold cyan] does not exist on IPFS")
@@ -331,7 +355,7 @@ async def handle_store(
                 )
 
             # Display download command in a panel
-            command = f"hippius download {result['cid']} <output_path>"
+            command = f"[bold green underline]hippius download {result['cid']} <output_path>[/bold green underline]"
             print_panel(command, title="Download Command")
 
             return 0
@@ -347,6 +371,7 @@ async def handle_store_dir(
     dir_path: str,
     miner_ids: Optional[List[str]] = None,
     encrypt: Optional[bool] = None,
+    publish: bool = True,
 ) -> int:
     """Handle the store directory command"""
     if not os.path.exists(dir_path):
@@ -406,12 +431,44 @@ async def handle_store_dir(
         updater = asyncio.create_task(update_progress())
 
         try:
+            # Upload info message based on publish flag
+            if not publish:
+                upload_info.append(
+                    "[bold yellow]Publishing: Disabled (local upload only)[/bold yellow]"
+                )
+                log(
+                    "\nUpload will be local only - not publishing to blockchain or pinning to IPFS"
+                )
+            else:
+                upload_info.append(
+                    "[bold green]Publishing: Enabled (publishing to blockchain)[/bold green]"
+                )
+
+            # Display updated upload information panel
+            print_panel("\n".join(upload_info), title="Directory Upload Operation")
+
             # Use the store_directory method
             result = await client.ipfs_client.upload_directory(
                 dir_path=dir_path,
                 encrypt=encrypt,
             )
 
+            # Skip publishing to blockchain if publish is False
+            if not publish:
+                # Remove any blockchain-related data from result to ensure we don't try to use it
+                if "transaction_hash" in result:
+                    del result["transaction_hash"]
+            else:
+                # If we want to publish, make sure files are pinned globally
+                for file_info in result.get("files", []):
+                    if "cid" in file_info:
+                        try:
+                            await client.ipfs_client.publish_global(file_info["cid"])
+                        except Exception as e:
+                            warning(
+                                f"Failed to publish file {file_info['name']} globally: {str(e)}"
+                            )
+
             # Complete the progress
             progress.update(task, completed=100)
             # Cancel the updater task
@@ -450,11 +507,15 @@ async def handle_store_dir(
                     ["Index", "Filename", "CID"],
                 )
 
-            # If we stored in the marketplace
-            if "transaction_hash" in result:
+            # If publishing is enabled and we stored in the marketplace
+            if publish and "transaction_hash" in result:
                 log(
                     f"\nStored in marketplace. Transaction hash: [bold]{result['transaction_hash']}[/bold]"
                 )
+            elif not publish:
+                log(
+                    "\n[yellow]Files were uploaded locally only. No blockchain publication or IPFS pinning.[/yellow]"
+                )
 
             return 0
 
@@ -498,8 +559,7 @@ async def handle_credits(
                             "Please provide an account address with '--account_address' or set a default with:"
                         )
                         log(
-                            "  hippius address set-default <your_account_address>",
-                            style="bold blue",
+                            "  [bold green underline]hippius address set-default <your_account_address>[/bold green underline]"
                         )
 
                     return 1
@@ -555,7 +615,9 @@ async def handle_files(
                     info(
                         "Please provide an account address with '--account_address' or set a default with:"
                     )
-                    log("  hippius address set-default <your_account_address>")
+                    log(
+                        "  [bold green underline]hippius address set-default <your_account_address>[/bold green underline]"
+                    )
                 return 1
 
     # Get files from the marketplace
@@ -707,7 +769,9 @@ async def handle_ec_files(
                     info(
                         "Please provide an account address with '--account_address' or set a default with:"
                     )
-                    log("  hippius address set-default <your_account_address>")
+                    log(
+                        "  [bold green underline]hippius address set-default <your_account_address>[/bold green underline]"
+                    )
                 return 1
 
     info(f"Getting erasure-coded files for account: [bold]{account_address}[/bold]")
@@ -937,7 +1001,7 @@ async def handle_ec_files(
         # Include a real example with the first metadata CID
         example_cid = metadata_cids[0] if metadata_cids else "<METADATA_CID>"
         print_panel(
-            f"hippius reconstruct <METADATA_CID> <OUTPUT_FILENAME>\n\nExample:\nhippius reconstruct {example_cid} reconstructed_file.bin",
+            f"[bold green underline]hippius reconstruct <METADATA_CID> <OUTPUT_FILENAME>[/bold green underline]\n\nExample:\n[bold green underline]hippius reconstruct {example_cid} reconstructed_file.bin[/bold green underline]",
             title="Reconstruction Command",
         )
 
@@ -969,10 +1033,44 @@ async def handle_erasure_code(
         import zfec
     except ImportError:
         error("zfec is required for erasure coding")
-        log("Install it with: [bold]pip install zfec[/bold]")
-        log("Then update your environment: [bold]poetry add zfec[/bold]")
+        log(
+            "Install it with: [bold green underline]pip install zfec[/bold green underline]"
+        )
+        log(
+            "Then update your environment: [bold green underline]poetry add zfec[/bold green underline]"
+        )
         return 1
 
+    # Request password early if we're going to publish to the blockchain
+    if publish and client.substrate_client._seed_phrase is None:
+        # First check if we have an encrypted seed phrase that will require a password
+        config = load_config()
+        account_name = client.substrate_client._account_name or get_active_account()
+
+        if account_name and account_name in config["substrate"].get("accounts", {}):
+            account_data = config["substrate"]["accounts"][account_name]
+            is_encoded = account_data.get("seed_phrase_encoded", False)
+
+            if is_encoded:
+                warning("Wallet password will be required for publishing to blockchain")
+                password = getpass.getpass(
+                    "Enter password to decrypt seed phrase: \n\n"
+                )
+
+                # Store the password in client for later use
+                client.substrate_client._seed_phrase_password = password
+
+                # Pre-authenticate to ensure the password is correct
+                try:
+                    seed_phrase = decrypt_seed_phrase(password, account_name)
+                    if not seed_phrase:
+                        error("Failed to decrypt seed phrase. Incorrect password?")
+                        return 1
+                    client.substrate_client._seed_phrase = seed_phrase
+                except Exception as e:
+                    error(f"Error decrypting seed phrase: {e}")
+                    return 1
+
     # Get file size
     file_size = os.path.getsize(file_path)
     file_name = os.path.basename(file_path)
@@ -989,21 +1087,31 @@ async def handle_erasure_code(
         # Calculate new chunk size to get exactly k chunks
         new_chunk_size = file_size / k
 
+        new_chunk_size = int(new_chunk_size)
+        new_chunk_size = max(1, new_chunk_size)
+
         # Create a panel with parameter adjustment information
         adjustment_info = [
-            f"Original parameters: k=[bold]{k}[/bold], m=[bold]{m}[/bold], chunk size=[bold]{chunk_size/1024/1024:.2f} MB[/bold]",
+            f"Original parameters: k=[bold]{k}[/bold], m=[bold]{m}[/bold], chunk size=[bold]{chunk_size / 1024 / 1024:.2f} MB[/bold]",
             f"Would create only [bold red]{potential_chunks:.2f}[/bold red] chunks, which is less than k=[bold]{k}[/bold]",
-            f"Automatically adjusting chunk size to [bold green]{new_chunk_size/1024/1024:.6f} MB[/bold green] to create at least {k} chunks",
+            f"Automatically adjusting chunk size to [bold green]{new_chunk_size / 1024 / 1024:.6f} MB[/bold green] to create at least {k} chunks",
         ]
         print_panel("\n".join(adjustment_info), title="Parameter Adjustment")
 
         chunk_size = new_chunk_size
 
+    # Calculate total number of chunks that will be created
+    total_original_chunks = max(1, int(math.ceil(file_size / chunk_size)))
+    total_encoded_chunks = total_original_chunks * m
+    estimated_size_per_chunk = min(chunk_size, file_size / total_original_chunks)
+
     # Create parameter information panel
     param_info = [
-        f"File: [bold]{file_name}[/bold] ([bold cyan]{file_size/1024/1024:.2f} MB[/bold cyan])",
+        f"File: [bold]{file_name}[/bold] ([bold cyan]{file_size / 1024 / 1024:.2f} MB[/bold cyan])",
         f"Parameters: k=[bold]{k}[/bold], m=[bold]{m}[/bold] (need {k} of {m} chunks to reconstruct)",
-        f"Chunk size: [bold cyan]{chunk_size/1024/1024:.6f} MB[/bold cyan]",
+        f"Chunk size: [bold cyan]{chunk_size / 1024 / 1024:.6f} MB[/bold cyan]",
+        f"Total chunks to be created: [bold yellow]{total_encoded_chunks}[/bold yellow] ({total_original_chunks} original chunks × {m} encoded chunks each)",
+        f"Estimated storage required: [bold magenta]{(total_encoded_chunks * estimated_size_per_chunk) / (1024 * 1024):.2f} MB[/bold magenta]",
     ]
 
     # Add encryption status
@@ -1012,6 +1120,16 @@ async def handle_erasure_code(
     else:
         param_info.append("[bold yellow]Encryption: Disabled[/bold yellow]")
 
+    # Add publish status
+    if publish:
+        param_info.append(
+            "[bold blue]Publishing: Enabled[/bold blue] (will store on blockchain)"
+        )
+    else:
+        param_info.append(
+            "[bold cyan]Publishing: Disabled[/bold cyan] (local only, no password needed)"
+        )
+
     # Parse miner IDs if provided
     miner_id_list = None
     if miner_ids:
@@ -1028,7 +1146,9 @@ async def handle_erasure_code(
     # Create progress for the erasure coding operation
     with create_progress() as progress:
         # Add tasks for the different stages
-        processing_task = progress.add_task("[cyan]Processing file...", total=100)
+        processing_task = progress.add_task(
+            "[cyan]Processing file...", total=100, visible=False
+        )
         encoding_task = progress.add_task(
             "[green]Encoding chunks...", total=100, visible=False
         )
@@ -1087,6 +1207,7 @@ async def handle_erasure_code(
                 max_retries=3,
                 verbose=verbose,
                 progress_callback=update_progress_bar,
+                publish=publish,
             )
 
             # Complete all progress tasks
@@ -1145,7 +1266,7 @@ async def handle_erasure_code(
                 # Use direct values from input parameters when metadata is not available
                 summary_lines.extend(
                     [
-                        f"Original file: [bold]{file_name}[/bold] ([bold cyan]{file_size/1024/1024:.2f} MB[/bold cyan])",
+                        f"Original file: [bold]{file_name}[/bold] ([bold cyan]{file_size / 1024 / 1024:.2f} MB[/bold cyan])",
                         f"Parameters: k=[bold]{k}[/bold], m=[bold]{m}[/bold]",
                         f"Total files stored in marketplace: [bold]{total_files_stored}[/bold]",
                         f"Metadata CID: [bold cyan]{metadata_cid}[/bold cyan]",
@@ -1156,14 +1277,14 @@ async def handle_erasure_code(
                 if publish:
                     summary_lines.extend(
                         [
-                            f"Published to global IPFS: [bold green]Yes[/bold green]",
+                            "Published to global IPFS: [bold green]Yes[/bold green]",
                             f"Global access URL: [link]{client.ipfs_client.gateway}/ipfs/{metadata_cid}[/link]",
                         ]
                     )
             else:
                 summary_lines.extend(
                     [
-                        f"Original file: [bold]{original_file.get('name')}[/bold] ([bold cyan]{original_file.get('size', 0)/1024/1024:.2f} MB[/bold cyan])",
+                        f"Original file: [bold]{original_file.get('name')}[/bold] ([bold cyan]{original_file.get('size', 0) / 1024 / 1024:.2f} MB[/bold cyan])",
                         f"File ID: [bold]{erasure_coding.get('file_id')}[/bold]",
                         f"Parameters: k=[bold]{erasure_coding.get('k')}[/bold], m=[bold]{erasure_coding.get('m')}[/bold]",
                         f"Total chunks: [bold]{len(metadata.get('chunks', []))}[/bold]",
@@ -1176,7 +1297,7 @@ async def handle_erasure_code(
                 if publish:
                     summary_lines.extend(
                         [
-                            f"Published to global IPFS: [bold green]Yes[/bold green]",
+                            "Published to global IPFS: [bold green]Yes[/bold green]",
                             f"Global access URL: [link]{client.ipfs_client.gateway}/ipfs/{metadata_cid}[/link]",
                         ]
                     )
@@ -1202,7 +1323,7 @@ async def handle_erasure_code(
                 f"  2. Access to at least [bold]{k}[/bold] chunks for each original chunk",
                 "",
                 "Reconstruction command:",
-                f"[bold]hippius reconstruct {metadata_cid} reconstructed_{output_filename}[/bold]",
+                f"[bold green underline]hippius reconstruct {metadata_cid} reconstructed_{output_filename}[/bold green underline]",
             ]
 
             print_panel(
@@ -1360,89 +1481,210 @@ async def handle_reconstruct(
 
 
 async def handle_delete(client: HippiusClient, cid: str, force: bool = False) -> int:
-    """Handle the delete command"""
-    info(f"Preparing to delete file with CID: [bold cyan]{cid}[/bold cyan]")
+    """Handle the delete command for files or directories"""
+    info(f"Preparing to delete content with CID: [bold cyan]{cid}[/bold cyan]")
+
+    # First check if this is a directory
+    try:
+        exists_result = await client.exists(cid)
+        if not exists_result["exists"]:
+            error(f"CID [bold cyan]{cid}[/bold cyan] not found on IPFS")
+            return 1
+    except Exception as e:
+        warning(f"Error checking if CID exists: {e}")
 
     if not force:
-        warning("This will cancel storage and remove the file from the marketplace.")
+        warning("This will cancel storage and remove the content from the marketplace.")
         confirm = input("Continue? (y/n): ").strip().lower()
         if confirm != "y":
             log("Deletion cancelled", style="yellow")
             return 0
 
-    info("Deleting file from marketplace...")
-    result = await client.delete_file(cid)
+    # Show spinner during deletion
+    with console.status("[cyan]Deleting content...[/cyan]", spinner="dots") as status:
+        result = await client.delete_file(cid)
 
-    if result.get("success"):
-        success("File successfully deleted")
+    # Display results
+    is_directory = result.get("is_directory", False)
+    child_files = result.get("child_files", [])
 
-        details = []
-        if "transaction_hash" in result:
-            details.append(
-                f"Transaction hash: [bold]{result['transaction_hash']}[/bold]"
-            )
-
-        # Create an informative panel with notes
-        notes = [
-            "1. The file is now unpinned from the marketplace",
-            "2. The CID may still resolve temporarily until garbage collection occurs",
-            "3. If the file was published to the global IPFS network, it may still be",
-            "   available through other nodes that pinned it",
+    if is_directory:
+        # Directory deletion
+        details = [
+            f"Successfully deleted directory: [bold cyan]{cid}[/bold cyan]",
+            f"Child files unpinned: [bold]{len(child_files)}[/bold]",
         ]
 
-        if details:
-            print_panel("\n".join(details), title="Transaction Details")
+        # If there are child files, show them in a table
+        if child_files:
+            table_data = []
+            for i, file in enumerate(
+                child_files[:10], 1
+            ):  # Limit to first 10 files if many
+                table_data.append(
+                    {
+                        "Index": str(i),
+                        "Filename": file.get("name", "unknown"),
+                        "CID": file.get("cid", "unknown"),
+                    }
+                )
 
-        print_panel("\n".join(notes), title="Important Notes")
+            if len(child_files) > 10:
+                table_data.append(
+                    {
+                        "Index": "...",
+                        "Filename": f"({len(child_files) - 10} more files)",
+                        "CID": "...",
+                    }
+                )
 
-        return 0
+            print_table(
+                "Unpinned Child Files", table_data, ["Index", "Filename", "CID"]
+            )
     else:
-        error(f"Failed to delete file: {result}")
+        # Regular file deletion
+        details = [f"Successfully deleted file: [bold cyan]{cid}[/bold cyan]"]
+
+    if "duration_seconds" in result.get("timing", {}):
+        details.append(
+            f"Deletion completed in [bold green]{result['timing']['duration_seconds']:.2f}[/bold green] seconds"
+        )
+
+    print_panel("\n".join(details), title="Deletion Complete")
+
+    # Create an informative panel with notes
+    notes = [
+        "1. The content is now unpinned from the marketplace",
+        "2. The CID may still resolve temporarily until garbage collection occurs",
+        "3. If the content was published to the global IPFS network, it may still be",
+        "   available through other nodes that pinned it",
+    ]
+
+    print_panel("\n".join(notes), title="Important Notes")
+
+    return 0
 
 
 async def handle_ec_delete(
     client: HippiusClient, metadata_cid: str, force: bool = False
 ) -> int:
-    """Handle the ec-delete command"""
-    info(
-        f"Preparing to delete erasure-coded file with metadata CID: [bold cyan]{metadata_cid}[/bold cyan]"
-    )
+    """Handle the erasure-code delete command"""
+
+    # Create a stylish header with the CID
+    info(f"Preparing to delete erasure-coded file with metadata CID:")
+    print_panel(f"[bold cyan]{metadata_cid}[/bold cyan]", title="Metadata CID")
 
+    # Confirm the deletion if not forced
     if not force:
-        warning("This will delete the metadata and all chunks from the marketplace.")
-        confirm = input("Continue? (y/n): ").strip().lower()
+        warning_text = [
+            "This will cancel the storage of this file on the Hippius blockchain.",
+            "The file metadata will be removed from blockchain storage tracking.",
+            "[dim]Note: Only the metadata CID will be canceled; contents may remain on IPFS.[/dim]",
+        ]
+        print_panel("\n".join(warning_text), title="Warning")
+
+        confirm = input("Continue with deletion? (y/n): ").strip().lower()
         if confirm != "y":
             log("Deletion cancelled", style="yellow")
             return 0
 
     try:
+        # First, pre-authenticate the client to get any password prompts out of the way
+        # This accesses the substrate client to trigger authentication
+        if not client.substrate_client._keypair:
+            client.substrate_client._ensure_keypair()
+
+        # Now we can show the spinner after any password prompts
         info("Deleting erasure-coded file from marketplace...")
-        result = await client.delete_ec_file(metadata_cid)
 
-        if result.get("success"):
-            success("Erasure-coded file successfully deleted")
+        # Create a more detailed spinner with phases
+        with console.status(
+            "[cyan]Processing file metadata and chunks...[/cyan]", spinner="dots"
+        ) as status:
+            try:
+                # Use the specialized delete method that now throws specific exceptions
+                await client.delete_ec_file(metadata_cid)
 
-            # Show detailed results
-            details = []
-            chunks_deleted = result.get("chunks_deleted", 0)
-            details.append(f"Deleted [bold]{chunks_deleted}[/bold] chunks")
+                # If we get here, deletion was successful
+                deletion_success = True
+                already_deleted = False
 
-            if "transaction_hash" in result:
-                details.append(
-                    f"Transaction hash: [bold]{result['transaction_hash']}[/bold]"
+            except HippiusAlreadyDeletedError:
+                # Special case - already deleted
+                deletion_success = False
+                already_deleted = True
+
+            except HippiusFailedSubstrateDelete as e:
+                # Blockchain deletion failed
+                error(f"Blockchain storage cancellation failed: {e}")
+                return 1
+
+            except HippiusFailedIPFSUnpin as e:
+                # IPFS unpinning failed, but blockchain deletion succeeded
+                warning(
+                    f"Note: Some IPFS operations failed, but blockchain storage was successfully canceled"
                 )
+                # Consider this a success for the user since the more important blockchain part worked
+                deletion_success = True
+                already_deleted = False
+
+            except HippiusMetadataError as e:
+                # Metadata parsing failed, but we can still continue
+                warning(
+                    f"Note: Metadata file was corrupted, but blockchain storage was successfully canceled"
+                )
+                # Consider this a success for the user since the blockchain part worked
+                deletion_success = True
+                already_deleted = False
 
-            print_panel("\n".join(details), title="Deletion Results")
+            except Exception as e:
+                # Handle any unexpected errors
+                error(f"Unexpected error: {e}")
+                return 1
 
+        # Show the result
+        if deletion_success:
+            # Create a success panel
+            success_panel = [
+                "[bold green]✓[/bold green] Metadata CID canceled from blockchain storage",
+                f"[dim]This file is no longer tracked for storage payments[/dim]",
+                "",
+                "[dim]To purge file data completely:[/dim]",
+                "• Individual chunks may still exist on IPFS and nodes",
+                "• For complete deletion, all chunks should be unpinned manually",
+            ]
+            print_panel(
+                "\n".join(success_panel), title="Storage Cancellation Successful"
+            )
+            return 0
+        elif already_deleted:
+            # Create a panel for the already deleted case
+            already_panel = [
+                "[bold yellow]![/bold yellow] This file has already been deleted from storage",
+                "[dim]The CID was not found in the blockchain storage registry[/dim]",
+                "",
+                "This is expected if:",
+                "• You previously deleted this file",
+                "• The file was deleted by another process",
+                "• The file was never stored in the first place",
+            ]
+            print_panel("\n".join(already_panel), title="Already Deleted")
+            # Return 0 since this is not an error condition
             return 0
         else:
-            error(
-                f"Failed to delete erasure-coded file: {result.get('message', 'Unknown error')}"
-            )
+            # Create an error panel for all other failures
+            error_panel = [
+                "[bold red]×[/bold red] File not found in blockchain storage",
+                "[dim]The metadata CID was not found in the blockchain storage registry[/dim]",
+                "",
+                "Possible reasons:",
+                "• The CID may be incorrect",
+                "• You may not be the owner of this file",
+            ]
+            print_panel("\n".join(error_panel), title="Storage Cancellation Failed")
             return 1
-
     except Exception as e:
-        error(f"Failed to delete erasure-coded file: {e}")
+        error(f"Error deleting erasure-coded file: {e}")
         return 1
 
 
@@ -1593,67 +1835,116 @@ def handle_seed_phrase_set(
 def handle_seed_phrase_encode(account_name: Optional[str] = None) -> int:
     """Handle the seed encode command"""
     try:
-        # Check if seed phrase exists
-        seed_phrase = get_seed_phrase(account_name)
+        # Check if account exists and get its encryption status
+        config = load_config()
+        accounts = config.get("substrate", {}).get("accounts", {})
 
-        if not seed_phrase:
-            print("Error: No seed phrase found to encrypt")
-            if account_name:
-                print(
-                    f"Account '{account_name}' may not exist or doesn't have a seed phrase"
-                )
-            else:
-                print("Set a seed phrase first with: hippius seed set <seed_phrase>")
+        # If account name not specified, use active account
+        if not account_name:
+            account_name = config.get("substrate", {}).get("active_account")
+            if not account_name:
+                error("No account specified and no active account")
+                return 1
+
+        # Check if the account exists
+        if account_name not in accounts:
+            error(f"Account '{account_name}' not found")
             return 1
 
-        # Check if already encrypted
-        config = load_config()
-        accounts = config.get("substrate", {}).get("accounts", {})
+        # Get account details
+        account = accounts.get(account_name, {})
+        is_encrypted = account.get("seed_phrase_encoded", False)
+        seed_phrase = account.get("seed_phrase")
 
-        if account_name:
-            account = accounts.get(account_name, {})
-            is_encrypted = account.get("encrypted", False)
-        else:
-            is_encrypted = config.get("substrate", {}).get("encrypted", False)
+        # Check if we have a seed phrase
+        if not seed_phrase:
+            error(f"Account '{account_name}' doesn't have a seed phrase")
+            info(
+                f"Set a seed phrase first with: [bold green underline]hippius seed set <seed_phrase> --account {account_name}[/bold green underline]"
+            )
+            return 1
 
+        # Check if the seed phrase is already encrypted
         if is_encrypted:
-            print("Seed phrase is already encrypted")
+            info("Seed phrase is already encrypted")
             confirm = (
                 input("Do you want to re-encrypt it with a new password? (y/n): ")
                 .strip()
                 .lower()
             )
             if confirm != "y":
-                print("Encryption cancelled")
+                info("Encryption cancelled")
                 return 0
 
-        # Get password for encryption
-        print("\nYou are about to encrypt your seed phrase.")
+            # Need to decrypt with old password first
+            old_password = getpass.getpass("Enter your current password to decrypt: ")
+            decrypted_seed_phrase = decrypt_seed_phrase(old_password, account_name)
+
+            if not decrypted_seed_phrase:
+                error("Unable to decrypt the seed phrase. Incorrect password?")
+                return 1
+
+            # Now we have the decrypted seed phrase
+            seed_phrase = decrypted_seed_phrase
+
+        # Get new password for encryption
+        info("\nYou are about to encrypt your seed phrase.")
         password = getpass.getpass("Enter a password for encryption: ")
         confirm = getpass.getpass("Confirm password: ")
 
         if password != confirm:
-            print("Error: Passwords do not match")
+            error("Passwords do not match")
             return 1
 
         if not password:
-            print("Error: Password cannot be empty for encryption")
+            error("Password cannot be empty for encryption")
             return 1
 
-        # Encrypt the seed phrase
-        encrypt_seed_phrase(password, account_name)
+        # Now encrypt the seed phrase - key fix here passing correct parameters
+        success = encrypt_seed_phrase(seed_phrase, password, account_name)
 
-        print("Seed phrase encrypted successfully")
-        print("You will need to provide this password when using the account")
+        # Security: Clear the plaintext seed phrase from memory
+        # This is a best-effort approach, as Python's garbage collection may still keep copies
+        seed_phrase = None
+
+        if success:
+            # Create success panel with encryption information
+            encryption_info = [
+                f"Account: [bold]{account_name}[/bold]",
+                "[bold green]Seed phrase encrypted successfully[/bold green]",
+                "",
+                "You will need to provide this password when using the account for:",
+                "  - Pinning files to IPFS",
+                "  - Erasure coding with publishing",
+                "  - Any other blockchain operations",
+                "",
+                "[bold yellow underline]Security note:[/bold yellow underline] The original unencrypted seed phrase is NOT stored in the config.",
+            ]
+
+            # Try to get the address for display
+            try:
+                address = get_account_address(account_name)
+                if address:
+                    encryption_info.append("")
+                    encryption_info.append(
+                        f"Account address: [bold cyan]{address}[/bold cyan]"
+                    )
+            except Exception:
+                pass
+
+            print_panel("\n".join(encryption_info), title="Encryption Successful")
+            return 0
+        else:
+            error("Failed to encrypt seed phrase")
+            return 1
 
-        return 0
     except Exception as e:
-        print(f"Error encrypting seed phrase: {e}")
+        error(f"Error encrypting seed phrase: {e}")
         return 1
 
 
 def handle_seed_phrase_decode(account_name: Optional[str] = None) -> int:
-    """Handle the seed decode command"""
+    """Handle the seed decode command - temporarily decrypts and displays the seed phrase"""
     try:
         # Check if seed phrase exists and is encrypted
         config = load_config()
@@ -1661,19 +1952,29 @@ def handle_seed_phrase_decode(account_name: Optional[str] = None) -> int:
 
         if account_name:
             account = accounts.get(account_name, {})
-            is_encrypted = account.get("encrypted", False)
+            is_encrypted = account.get("seed_phrase_encoded", False)
         else:
-            is_encrypted = config.get("substrate", {}).get("encrypted", False)
+            # Get active account
+            active_account = config.get("substrate", {}).get("active_account")
+            if active_account and active_account in accounts:
+                is_encrypted = accounts[active_account].get(
+                    "seed_phrase_encoded", False
+                )
+            else:
+                # Legacy mode
+                is_encrypted = config.get("substrate", {}).get(
+                    "seed_phrase_encoded", False
+                )
 
         if not is_encrypted:
-            print("Seed phrase is not encrypted")
+            info("Seed phrase is not encrypted")
             return 0
 
         # Get password for decryption
         password = getpass.getpass("Enter your password to decrypt the seed phrase: ")
 
         if not password:
-            print("Error: Password cannot be empty")
+            error("Password cannot be empty")
             return 1
 
         # Try to decrypt the seed phrase
@@ -1681,30 +1982,40 @@ def handle_seed_phrase_decode(account_name: Optional[str] = None) -> int:
             seed_phrase = decrypt_seed_phrase(password, account_name)
 
             if seed_phrase:
-                print("\nDecrypted seed phrase:")
-                print(seed_phrase)
+                # Create info panel for the decrypted seed phrase
+                seed_info = [
+                    f"Decrypted seed phrase: [bold yellow]{seed_phrase}[/bold yellow]",
+                    "",
+                    "[bold green underline]NOTE: This is a temporary decryption only. Your seed phrase remains encrypted in the config.[/bold green underline]",
+                    "",
+                    "[bold red underline]SECURITY WARNING:[/bold red underline]",
+                    "- Your seed phrase gives full access to your account funds",
+                    "- Never share it with anyone or store it in an insecure location",
+                    "- Be aware that displaying it on screen could expose it to screen capture",
+                    "- Consider clearing your terminal history after this operation",
+                ]
 
-                # Security warning
-                print(
-                    "\nWARNING: Your seed phrase gives full access to your account funds."
-                )
-                print("Never share it with anyone or store it in an insecure location.")
+                print_panel("\n".join(seed_info), title="Seed Phrase Decoded")
+
+                # Security: Clear the plaintext seed phrase from memory
+                # This is a best-effort approach, as Python's garbage collection may still keep copies
+                seed_phrase = None
 
                 return 0
             else:
-                print("Error: Failed to decrypt seed phrase")
+                error("Failed to decrypt seed phrase")
                 return 1
 
         except Exception as e:
-            print(f"Error decrypting seed phrase: {e}")
+            error(f"Error decrypting seed phrase: {e}")
 
             if "decryption failed" in str(e).lower():
-                print("Incorrect password")
+                warning("Incorrect password")
 
             return 1
 
     except Exception as e:
-        print(f"Error: {e}")
+        error(f"{e}")
         return 1
 
 
@@ -1725,7 +2036,7 @@ def handle_seed_phrase_status(account_name: Optional[str] = None) -> int:
 
             account = accounts[account_name]
             has_seed = "seed_phrase" in account
-            is_encrypted = account.get("encrypted", False)
+            is_encrypted = account.get("seed_phrase_encoded", False)
             is_active = account_name == get_active_account()
 
             print("\nAccount Status:")
@@ -1746,31 +2057,39 @@ def handle_seed_phrase_status(account_name: Optional[str] = None) -> int:
                         print(f"  Address: Unable to derive (Error: {e})")
 
         else:
-            print("Checking default seed phrase status")
-
-            # Check default seed phrase
-            has_seed = "seed_phrase" in config.get("substrate", {})
-            is_encrypted = config.get("substrate", {}).get("encrypted", False)
-
-            print("\nDefault Seed Phrase Status:")
-            print(f"  Has Seed Phrase: {'Yes' if has_seed else 'No'}")
-            print(f"  Encrypted: {'Yes' if is_encrypted else 'No'}")
-
-            if has_seed:
-                try:
-                    # Try to get the address (will use cached if available)
-                    address = get_account_address()
-                    print(f"  Address: {address}")
-                except Exception as e:
-                    if is_encrypted:
-                        print("  Address: Encrypted (password required to view)")
-                    else:
-                        print(f"  Address: Unable to derive (Error: {e})")
+            print("Checking active account seed phrase status")
 
-            # Show active account
+            # Get the active account
             active_account = get_active_account()
             if active_account:
-                print(f"\nActive Account: {active_account}")
+                accounts = config.get("substrate", {}).get("accounts", {})
+                if active_account in accounts:
+                    account = accounts[active_account]
+                    has_seed = "seed_phrase" in account
+                    is_encrypted = account.get("seed_phrase_encoded", False)
+
+                    print(f"\nActive Account: {active_account}")
+                    print(f"  Has Seed Phrase: {'Yes' if has_seed else 'No'}")
+                    print(f"  Encrypted: {'Yes' if is_encrypted else 'No'}")
+
+                    if has_seed:
+                        try:
+                            # Try to get the address (will use cached if available)
+                            address = get_account_address(active_account)
+                            print(f"  Address: {address}")
+                        except Exception as e:
+                            if is_encrypted:
+                                print(
+                                    "  Address: Encrypted (password required to view)"
+                                )
+                            else:
+                                print(f"  Address: Unable to derive (Error: {e})")
+                else:
+                    print(
+                        f"\nActive account '{active_account}' not found in configuration"
+                    )
+            else:
+                print("\nNo active account set")
 
         return 0
 
@@ -1784,6 +2103,88 @@ def handle_seed_phrase_status(account_name: Optional[str] = None) -> int:
 #
 
 
+def handle_account_info(account_name: Optional[str] = None) -> int:
+    """Handle the account info command - displays detailed information about an account"""
+    try:
+        # Load configuration
+        config = load_config()
+
+        # If account name not specified, use active account
+        if not account_name:
+            account_name = config.get("substrate", {}).get("active_account")
+            if not account_name:
+                error("No account specified and no active account")
+                return 1
+
+        # Check if account exists
+        accounts = config.get("substrate", {}).get("accounts", {})
+        if account_name not in accounts:
+            error(f"Account '{account_name}' not found")
+            return 1
+
+        # Get account details
+        account = accounts[account_name]
+        has_seed = "seed_phrase" in account
+        is_encrypted = account.get("seed_phrase_encoded", False)
+        is_active = account_name == get_active_account()
+        ss58_address = account.get("ss58_address", "")
+
+        # Account information panel with rich formatting
+        account_info = [
+            f"Account Name: [bold]{account_name}[/bold]",
+            f"Active: [bold cyan]{'Yes' if is_active else 'No'}[/bold cyan]",
+            f"Has Seed Phrase: [bold]{'Yes' if has_seed else 'No'}[/bold]",
+            f"Encryption: [bold {'green' if is_encrypted else 'yellow'}]{'Encrypted' if is_encrypted else 'Unencrypted'}[/bold {'green' if is_encrypted else 'yellow'}]",
+        ]
+
+        if ss58_address:
+            account_info.append(f"SS58 Address: [bold cyan]{ss58_address}[/bold cyan]")
+        elif has_seed:
+            if is_encrypted:
+                account_info.append(
+                    "[dim]Address: Encrypted (password required to view)[/dim]"
+                )
+            else:
+                try:
+                    # Try to get the address
+                    address = get_account_address(account_name)
+                    account_info.append(
+                        f"SS58 Address: [bold cyan]{address}[/bold cyan]"
+                    )
+                except Exception as e:
+                    account_info.append(
+                        f"[yellow]Unable to derive address: {e}[/yellow]"
+                    )
+
+        # Add suggestions based on account status
+        account_info.append("")
+        if is_active:
+            account_info.append("[bold green]This is your active account[/bold green]")
+        else:
+            account_info.append(
+                f"[dim]To use this account: [bold green underline]hippius account switch {account_name}[/bold green underline][/dim]"
+            )
+
+        if has_seed and not is_encrypted:
+            account_info.append(
+                f"[bold yellow underline]WARNING:[/bold yellow underline] Seed phrase is not encrypted"
+            )
+            account_info.append(
+                f"[dim]To encrypt: [bold green underline]hippius account encode --name {account_name}[/bold green underline][/dim]"
+            )
+
+        # Print the panel with rich formatting
+        print_panel(
+            "\n".join(account_info), title=f"Account Information: {account_name}"
+        )
+
+        return 0
+
+    except Exception as e:
+        error(f"Error getting account info: {e}")
+        return 1
+
+
 def handle_account_create(
     client: HippiusClient, name: str, encrypt: bool = False
 ) -> int:
@@ -1797,6 +2198,9 @@ def handle_account_create(
 
         print(f"Creating new account: {name}")
 
+        # Import Keypair at the beginning to ensure it's available
+        from substrateinterface import Keypair
+
         # Generate a new keypair (seed phrase)
         seed_phrase = client.substrate_client.generate_seed_phrase()
 
@@ -1820,56 +2224,70 @@ def handle_account_create(
                 return 1
 
         # Set the seed phrase for the new account
-        set_seed_phrase(seed_phrase, password, name)
+        # First load the config to directly edit it
+        config = load_config()
 
-        # Set as active account
-        set_active_account(name)
+        # Ensure accounts structure exists
+        if "accounts" not in config["substrate"]:
+            config["substrate"]["accounts"] = {}
 
-        # Get account address
-        try:
-            if password:
-                # Create a temporary client with the password to get the address
-                temp_client = HippiusClient(
-                    substrate_seed_phrase=seed_phrase,
-                    seed_phrase_password=password,
-                    account_name=name,
-                )
-                address = temp_client.substrate_client.get_account_address()
-            else:
-                address = get_account_address(name)
+        # Create keypair directly from seed phrase
+        keypair = Keypair.create_from_mnemonic(seed_phrase)
+        address = keypair.ss58_address
 
-            print(f"\nCreated new account: {name}")
-            print(f"Address: {address}")
-            print(f"Seed phrase: {seed_phrase}")
-            print(
-                "\nIMPORTANT: Keep your seed phrase safe. It's the only way to recover your account!"
-            )
+        # Add the new account
+        config["substrate"]["accounts"][name] = {
+            "seed_phrase": seed_phrase,
+            "seed_phrase_encoded": False,
+            "seed_phrase_salt": None,
+            "ss58_address": address,
+        }
 
-            # Encryption status
-            if encrypt:
-                print("\nYour seed phrase is encrypted.")
-                print(
-                    "You'll need to provide the password whenever using this account."
-                )
-            else:
-                print("\nWARNING: Your seed phrase is stored unencrypted.")
-                print(
-                    "Consider encrypting it with: hippius account encode --name", name
-                )
+        # Set as active account
+        config["substrate"]["active_account"] = name
 
-            print("\nThis account is now active. Use it with: hippius <command>")
+        # Save the config
+        save_config(config)
 
-            return 0
+        # Print account information using rich formatting
+        account_info = [
+            f"Account: [bold]{name}[/bold]",
+            f"Address: [bold cyan]{address}[/bold cyan]",
+            f"Seed phrase: [bold yellow]{seed_phrase}[/bold yellow]",
+            "",
+            "[bold red underline]IMPORTANT:[/bold red underline] Keep your seed phrase safe. It's the only way to recover your account!",
+        ]
 
-        except Exception as e:
-            print(f"Account created but failed to get address: {e}")
-            print(
-                f"The seed phrase has been saved but you may need to fix the configuration."
+        # Add encryption status
+        if encrypt:
+            account_info.append("")
+            account_info.append(
+                "[bold green]Your seed phrase is encrypted.[/bold green]"
             )
-            return 1
+            account_info.append(
+                "You'll need to provide the password whenever using this account."
+            )
+        else:
+            account_info.append("")
+            account_info.append(
+                "[bold yellow underline]WARNING:[/bold yellow underline] Your seed phrase is stored unencrypted."
+            )
+            account_info.append(
+                f"[bold green underline]Consider encrypting it with: hippius account encode --name {name}[/bold green underline]"
+            )
+
+        account_info.append("")
+        account_info.append(
+            "This account is now active. Use it with: [bold]hippius <command>[/bold]"
+        )
+
+        # Print the panel with rich formatting
+        print_panel("\n".join(account_info), title="Account Created Successfully")
+
+        return 0
 
     except Exception as e:
-        print(f"Error creating account: {e}")
+        error(f"Error creating account: {e}")
         return 1
 
 
@@ -2105,7 +2523,7 @@ def handle_account_list() -> int:
 
             is_active = account_name == active_account
             has_seed = "seed_phrase" in account_data
-            is_encrypted = account_data.get("encrypted", False)
+            is_encrypted = account_data.get("seed_phrase_encoded", False)
 
             # Get address
             address = account_data.get("ss58_address", "")
@@ -2136,8 +2554,8 @@ def handle_account_list() -> int:
 
         # Instructions
         help_text = [
-            "To switch accounts: [bold]hippius account switch <account_name>[/bold]",
-            "To create a new account: [bold]hippius account create --name <account_name>[/bold]",
+            "To switch accounts: [bold green underline]hippius account switch <account_name>[/bold green underline]",
+            "To create a new account: [bold green underline]hippius account create --name <account_name>[/bold green underline]",
         ]
         print_panel("\n".join(help_text), title="Account Management")
 
@@ -2188,6 +2606,199 @@ def handle_account_switch(account_name: str) -> int:
         return 1
 
 
+def handle_account_login() -> int:
+    """Handle the account login command - prompts for account details and creates an account"""
+    try:
+        # Display the login banner
+        from hippius_sdk.cli_assets import LOGIN_ASSET
+
+        console.print(LOGIN_ASSET, style="bold cyan")
+        console.print(
+            "\n[bold blue]Welcome to Hippius![/bold blue] Let's set up your account.\n"
+        )
+
+        # Create a style for prompts
+        prompt_style = "bold green"
+        input_style = "bold cyan"
+
+        # Prompt for account name with nice formatting
+        console.print(
+            "[bold]Step 1:[/bold] Choose a name for your account", style=prompt_style
+        )
+        console.print(
+            "This name will be used to identify your account in the Hippius system.",
+            style="dim",
+        )
+        console.print("Account name:", style=input_style, end=" ")
+        name = input().strip()
+
+        if not name:
+            error("[bold red]Account name cannot be empty[/bold red]")
+            return 1
+
+        # Check if account already exists
+        accounts = list_accounts()
+        if name in accounts:
+            warning(f"Account '[bold]{name}[/bold]' already exists")
+            console.print(
+                "Do you want to overwrite it? (y/n):", style=input_style, end=" "
+            )
+            confirm = input().strip().lower()
+            if confirm != "y":
+                info("Login cancelled")
+                return 0
+
+        # Prompt for seed phrase with detailed explanation
+        console.print(
+            "\n[bold]Step 2:[/bold] Enter your seed phrase", style=prompt_style
+        )
+        console.print(
+            "Your seed phrase gives access to your blockchain account and funds.",
+            style="dim",
+        )
+        console.print(
+            "[yellow]Important:[/yellow] Must be 12 or 24 words separated by spaces.",
+            style="dim",
+        )
+        console.print("Seed phrase:", style=input_style, end=" ")
+        seed_phrase = input().strip()
+
+        # Validate the seed phrase
+        if not seed_phrase or len(seed_phrase.split()) not in [12, 24]:
+            error(
+                "[bold red]Invalid seed phrase[/bold red] - must be 12 or 24 words separated by spaces"
+            )
+            return 1
+
+        # Prompt for encryption with security explanation
+        console.print("\n[bold]Step 3:[/bold] Secure your account", style=prompt_style)
+        console.print(
+            "Encrypting your seed phrase adds an extra layer of security.", style="dim"
+        )
+        console.print(
+            "[bold yellow]Strongly recommended[/bold yellow] to protect your account.",
+            style="dim",
+        )
+        console.print(
+            "Encrypt seed phrase? [bold green](Y/n)[/bold green]:",
+            style=input_style,
+            end=" ",
+        )
+        encrypt_input = input().strip().lower()
+        encrypt = encrypt_input == "y" or encrypt_input == "" or encrypt_input == "yes"
+
+        # Set up encryption if requested
+        password = None
+        if encrypt:
+            console.print(
+                "\n[bold]Step 4:[/bold] Set encryption password", style=prompt_style
+            )
+            console.print(
+                "This password will be required whenever you use your account for blockchain operations.",
+                style="dim",
+            )
+
+            password = getpass.getpass("Enter a password: ")
+            confirm = getpass.getpass("Confirm password: ")
+
+            if password != confirm:
+                error("[bold red]Passwords do not match[/bold red]")
+                return 1
+
+            if not password:
+                error("[bold red]Password cannot be empty for encryption[/bold red]")
+                return 1
+
+        # Initialize address variable
+        address = None
+
+        # Create and store the account
+        with console.status("[cyan]Setting up your account...[/cyan]", spinner="dots"):
+            # First, directly modify the config to ensure account is created
+            config = load_config()
+
+            # Ensure accounts structure exists
+            if "substrate" not in config:
+                config["substrate"] = {}
+            if "accounts" not in config["substrate"]:
+                config["substrate"]["accounts"] = {}
+
+            # Create keypair and get address from seed phrase
+            from substrateinterface import Keypair
+
+            keypair = Keypair.create_from_mnemonic(seed_phrase)
+            address = keypair.ss58_address
+
+            # Add the new account
+            config["substrate"]["accounts"][name] = {
+                "seed_phrase": seed_phrase,
+                "seed_phrase_encoded": False,
+                "seed_phrase_salt": None,
+                "ss58_address": address,
+            }
+
+            # Set as active account
+            config["substrate"]["active_account"] = name
+
+            # Save the config first
+            save_config(config)
+
+            # Now encrypt if requested
+            if encrypt:
+                encrypt_seed_phrase(seed_phrase, password, name)
+
+            time.sleep(0.5)  # Small delay for visual feedback
+
+        # Success panel with account information
+        account_info = [
+            f"[bold]Account Name:[/bold] [bold magenta]{name}[/bold magenta]",
+            f"[bold]Blockchain Address:[/bold] [bold cyan]{address}[/bold cyan]",
+            "",
+            "[bold green]✓ Login successful![/bold green]",
+            "[bold green]✓ Account set as active[/bold green]",
+        ]
+
+        if encrypt:
+            account_info.append("[bold green]✓ Seed phrase encrypted[/bold green]")
+            account_info.append("")
+            account_info.append(
+                "[dim]You'll need your password when using this account for blockchain operations.[/dim]"
+            )
+        else:
+            account_info.append(
+                "[bold yellow]⚠ Seed phrase not encrypted[/bold yellow]"
+            )
+            account_info.append("")
+            account_info.append(
+                "[dim]For better security, consider encrypting your seed phrase:[/dim]"
+            )
+            account_info.append(
+                f"[dim]  [bold green underline]hippius account encode --name {name}[/bold green underline][/dim]"
+            )
+
+        # Add next steps
+        account_info.append("")
+        account_info.append("[bold blue]Next steps:[/bold blue]")
+        account_info.append(
+            "• [bold green underline]hippius credits[/bold green underline] - Check your account balance"
+        )
+        account_info.append(
+            "• [bold green underline]hippius files[/bold green underline] - View your stored files"
+        )
+        account_info.append(
+            "• [bold green underline]hippius store <file>[/bold green underline] - Upload a file to IPFS"
+        )
+
+        print_panel(
+            "\n".join(account_info), title="[bold green]Account Ready[/bold green]"
+        )
+        return 0
+
+    except Exception as e:
+        error(f"[bold red]Error logging in:[/bold red] {e}")
+        return 1
+
+
 def handle_account_delete(account_name: str) -> int:
     """Handle the account delete command"""
     try: