redundanet 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

redundanet/__init__.py

@@ -8,9 +8,9 @@ from redundanet.core.config import NetworkConfig, NodeConfig, TahoeConfig
 from redundanet.core.manifest import Manifest
 
 __all__ = [
-    "__version__",
+    "Manifest",
     "NetworkConfig",
     "NodeConfig",
     "TahoeConfig",
-    "Manifest",
+    "__version__",
 ]

redundanet/auth/gpg.py

@@ -43,9 +43,9 @@ class GPGKeyInfo:
             fingerprint=key.get("fingerprint", ""),
             user_id=user_id,
             email=email,
-            created=key.get("date", None),
-            expires=key.get("expires", None),
-            trust=key.get("trust", None),
+            created=key.get("date"),
+            expires=key.get("expires"),
+            trust=key.get("trust"),
         )
 
 

redundanet/cli/node.py

@@ -266,40 +266,223 @@ def remove_node(
 def manage_keys(
     action: Annotated[
         str,
-        typer.Argument(help="Action: generate, export, import"),
+        typer.Argument(help="Action: generate, export, import, list, publish, fetch"),
     ],
     node_name: Annotated[
         Optional[str],
         typer.Option("--name", "-n", help="Node name"),
     ] = None,
+    email: Annotated[
+        Optional[str],
+        typer.Option("--email", "-e", help="Email address for the GPG key"),
+    ] = None,
+    key_id: Annotated[
+        Optional[str],
+        typer.Option("--key-id", "-k", help="Key ID for export/import operations"),
+    ] = None,
+    output_file: Annotated[
+        Optional[Path],
+        typer.Option("--output", "-o", help="Output file for export"),
+    ] = None,
+    input_file: Annotated[
+        Optional[Path],
+        typer.Option("--input", "-i", help="Input file for import"),
+    ] = None,
 ) -> None:
     """Manage GPG keys for node authentication."""
+    from redundanet.auth.gpg import GPGManager
     from redundanet.core.config import load_settings
+    from redundanet.core.exceptions import GPGError
 
     settings = load_settings()
     node_name = node_name or settings.node_name
 
-    if not node_name:
-        console.print("[red]Error:[/red] No node name specified")
-        console.print("Use --name or set REDUNDANET_NODE_NAME")
-        raise typer.Exit(1)
-
     if action == "generate":
+        if not node_name:
+            console.print("[red]Error:[/red] No node name specified")
+            console.print("Use --name or set REDUNDANET_NODE_NAME")
+            raise typer.Exit(1)
+
+        # Prompt for email if not provided
+        if not email:
+            email = typer.prompt("Enter email address for the GPG key")
+
         console.print(f"[bold]Generating GPG key for node: {node_name}[/bold]")
         console.print("[yellow]Note:[/yellow] This will create a new GPG keypair.")
-        console.print("Use 'redundanet node keys export' to share your public key.")
-        # In a real implementation, we'd call the GPG module
-        console.print("[dim]GPG key generation not yet implemented[/dim]")
+
+        try:
+            gpg = GPGManager(node_name=node_name)
+            with console.status("[bold green]Generating GPG key (this may take a moment)..."):
+                key_info = gpg.generate_key(
+                    name=f"RedundaNet Node {node_name}",
+                    email=email,
+                )
+
+            console.print("\n[bold green]GPG key generated successfully![/bold green]")
+            console.print(f"  Key ID:      [cyan]{key_info.key_id}[/cyan]")
+            console.print(f"  Fingerprint: [dim]{key_info.fingerprint}[/dim]")
+            console.print(f"  User ID:     {key_info.user_id}")
+
+            console.print("\n[bold]Next steps:[/bold]")
+            console.print(
+                f"1. Publish your key to keyservers: [cyan]redundanet node keys publish --key-id {key_info.key_id}[/cyan]"
+            )
+            console.print(
+                "2. Submit your application at: [cyan]https://redundanet.com/join.html[/cyan]"
+            )
+            console.print(f"3. Use this Key ID in your application: [cyan]{key_info.key_id}[/cyan]")
+
+        except GPGError as e:
+            console.print(f"[red]Error generating key:[/red] {e}")
+            raise typer.Exit(1) from None
 
     elif action == "export":
-        console.print(f"[bold]Exporting public key for node: {node_name}[/bold]")
-        console.print("[dim]Key export not yet implemented[/dim]")
+        if not key_id:
+            console.print("[red]Error:[/red] --key-id is required for export")
+            raise typer.Exit(1)
+
+        console.print(f"[bold]Exporting public key: {key_id}[/bold]")
+
+        try:
+            gpg = GPGManager()
+            public_key = gpg.export_public_key(key_id)
+
+            if output_file:
+                output_file.write_text(public_key)
+                console.print(f"[green]Public key exported to:[/green] {output_file}")
+            else:
+                console.print("\n[bold]Public Key:[/bold]")
+                console.print(public_key)
+
+        except GPGError as e:
+            console.print(f"[red]Error exporting key:[/red] {e}")
+            raise typer.Exit(1) from None
 
     elif action == "import":
-        console.print("[bold]Importing public key[/bold]")
-        console.print("[dim]Key import not yet implemented[/dim]")
+        if not input_file:
+            console.print("[red]Error:[/red] --input is required for import")
+            console.print("Provide a path to an ASCII-armored public key file")
+            raise typer.Exit(1)
+
+        if not input_file.exists():
+            console.print(f"[red]Error:[/red] File not found: {input_file}")
+            raise typer.Exit(1)
+
+        console.print(f"[bold]Importing public key from: {input_file}[/bold]")
+
+        try:
+            gpg = GPGManager()
+            key_data = input_file.read_text()
+            key_info = gpg.import_key(key_data)
+
+            console.print("[green]Key imported successfully![/green]")
+            console.print(f"  Key ID:      [cyan]{key_info.key_id}[/cyan]")
+            console.print(f"  Fingerprint: [dim]{key_info.fingerprint}[/dim]")
+            console.print(f"  User ID:     {key_info.user_id}")
+
+        except GPGError as e:
+            console.print(f"[red]Error importing key:[/red] {e}")
+            raise typer.Exit(1) from None
+
+    elif action == "list":
+        console.print("[bold]GPG Keys in Keyring:[/bold]")
+
+        try:
+            gpg = GPGManager()
+            keys = gpg.list_keys()
+
+            if not keys:
+                console.print("[dim]No keys found in keyring[/dim]")
+                return
+
+            table = Table()
+            table.add_column("Key ID", style="cyan")
+            table.add_column("User ID")
+            table.add_column("Created")
+            table.add_column("Expires")
+
+            for key in keys:
+                table.add_row(
+                    key.key_id,
+                    key.user_id,
+                    key.created or "[dim]unknown[/dim]",
+                    key.expires or "[dim]never[/dim]",
+                )
+
+            console.print(table)
+
+        except GPGError as e:
+            console.print(f"[red]Error listing keys:[/red] {e}")
+            raise typer.Exit(1) from None
+
+    elif action == "publish":
+        if not key_id:
+            console.print("[red]Error:[/red] --key-id is required for publish")
+            console.print("Use 'redundanet node keys list' to see your keys")
+            raise typer.Exit(1)
+
+        console.print(f"[bold]Publishing key to keyservers: {key_id}[/bold]")
+
+        try:
+            from redundanet.auth.keyserver import KeyServerClient
+            from redundanet.core.exceptions import KeyServerError
+
+            gpg = GPGManager()
+            keyserver_client = KeyServerClient(gpg)
+
+            with console.status("[bold green]Uploading to keyservers..."):
+                success = keyserver_client.upload_key(key_id)
+
+            if success:
+                console.print("[green]Key published successfully![/green]")
+                console.print("\nYour key is now available on public keyservers.")
+                console.print("Note: It may take a few minutes for the key to propagate.")
+                console.print("\n[bold]Keyservers used:[/bold]")
+                for server in keyserver_client.keyservers:
+                    console.print(f"  - {server}")
+            else:
+                console.print("[yellow]Warning:[/yellow] Failed to upload to any keyserver")
+                console.print("You may need to manually upload your key at:")
+                console.print("  - https://keys.openpgp.org/upload")
+                console.print("  - https://keyserver.ubuntu.com/")
+
+        except (GPGError, KeyServerError) as e:
+            console.print(f"[red]Error publishing key:[/red] {e}")
+            raise typer.Exit(1) from None
+
+    elif action == "fetch":
+        if not key_id:
+            console.print("[red]Error:[/red] --key-id is required for fetch")
+            raise typer.Exit(1)
+
+        console.print(f"[bold]Fetching key from keyservers: {key_id}[/bold]")
+
+        try:
+            from redundanet.auth.keyserver import KeyServerClient
+
+            gpg = GPGManager()
+            keyserver_client = KeyServerClient(gpg)
+
+            with console.status("[bold green]Searching keyservers..."):
+                success = keyserver_client.import_key_from_server(key_id)
+
+            if success:
+                console.print("[green]Key fetched and imported successfully![/green]")
+
+                # Show key info
+                fetched_key = gpg.get_key(key_id)
+                if fetched_key:
+                    console.print(f"  Key ID:  [cyan]{fetched_key.key_id}[/cyan]")
+                    console.print(f"  User ID: {fetched_key.user_id}")
+            else:
+                console.print(f"[red]Error:[/red] Key {key_id} not found on any keyserver")
+                raise typer.Exit(1)
+
+        except GPGError as e:
+            console.print(f"[red]Error fetching key:[/red] {e}")
+            raise typer.Exit(1) from None
 
     else:
         console.print(f"[red]Error:[/red] Unknown action '{action}'")
-        console.print("Valid actions: generate, export, import")
+        console.print("Valid actions: generate, export, import, list, publish, fetch")
         raise typer.Exit(1)

redundanet/network/__init__.py

@@ -5,7 +5,7 @@ from redundanet.network.dns import DNSManager
 from redundanet.network.validation import NetworkValidator
 
 __all__ = [
-    "NodeDiscovery",
-    "NetworkValidator",
     "DNSManager",
+    "NetworkValidator",
+    "NodeDiscovery",
 ]

redundanet/storage/__init__.py

@@ -6,8 +6,8 @@ from redundanet.storage.introducer import TahoeIntroducer
 from redundanet.storage.storage import TahoeStorage
 
 __all__ = [
+    "FURLManager",
     "TahoeClient",
-    "TahoeStorage",
     "TahoeIntroducer",
-    "FURLManager",
+    "TahoeStorage",
 ]

redundanet/utils/process.py

@@ -171,7 +171,7 @@ async def run_command_async(
             command=cmd_str,
         )
 
-    except asyncio.TimeoutError:
+    except TimeoutError:
         process.kill()
         await process.wait()
         logger.error("Async command timed out", command=cmd_str, timeout=timeout)

redundanet/vpn/__init__.py

@@ -5,8 +5,8 @@ from redundanet.vpn.mesh import MeshNetwork
 from redundanet.vpn.tinc import TincConfig, TincManager
 
 __all__ = [
-    "TincManager",
+    "MeshNetwork",
     "TincConfig",
+    "TincManager",
     "VPNKeyManager",
-    "MeshNetwork",
 ]

redundanet-2.0.1.dist-info/METADATA

@@ -0,0 +1,298 @@
+Metadata-Version: 2.1
+Name: redundanet
+Version: 2.0.1
+Summary: Distributed encrypted storage on a mesh VPN network
+Home-page: https://github.com/alessandrodefilippo/redundanet
+License: MIT
+Keywords: distributed-storage,vpn,encryption,mesh-network,tahoe-lafs
+Author: Alessandro De Filippo
+Author-email: alessandro@example.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Topic :: System :: Networking
+Requires-Dist: gitpython (>=3.1,<4.0)
+Requires-Dist: httpx (>=0.26,<0.27)
+Requires-Dist: jinja2 (>=3.1,<4.0)
+Requires-Dist: jsonschema (>=4.21,<5.0)
+Requires-Dist: psutil (>=5.9,<6.0)
+Requires-Dist: pydantic (>=2.5,<3.0)
+Requires-Dist: pydantic-settings (>=2.1,<3.0)
+Requires-Dist: python-gnupg (>=0.5,<0.6)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: rich (>=13.7,<14.0)
+Requires-Dist: structlog (>=24.1,<25.0)
+Requires-Dist: typer[all] (>=0.12.0)
+Requires-Dist: watchdog (>=4.0,<5.0)
+Project-URL: Documentation, https://redundanet.readthedocs.io
+Project-URL: Repository, https://github.com/alessandrodefilippo/redundanet
+Description-Content-Type: text/markdown
+
+# RedundaNet - Distributed Encrypted Storage Network
+
+[![CI](https://github.com/adefilippo83/redundanet/actions/workflows/ci.yml/badge.svg)](https://github.com/adefilippo83/redundanet/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/redundanet)](https://pypi.org/project/redundanet/)
+[![License](https://img.shields.io/github/license/adefilippo83/redundanet)](LICENSE)
+
+RedundaNet is a distributed, encrypted storage system built on a secure mesh VPN network. It enables users to contribute storage resources to a collective grid while maintaining privacy through end-to-end encryption.
+
+**Website**: [https://redundanet.com](https://redundanet.com)
+
+## Features
+
+- **Decentralized Architecture**: No central authority or single point of failure
+- **End-to-End Encryption**: Data is encrypted before leaving your device using Tahoe-LAFS
+- **GPG-Based Authentication**: Secure node identity verification via public keyservers
+- **Private Networking**: Secure Tinc mesh VPN isolates the storage network
+- **Erasure Coding**: Data is split and distributed across multiple nodes (3-of-10 scheme)
+- **Open Membership**: Anyone can apply to join the network
+- **Containerized Deployment**: Easy setup with Docker Compose
+- **Raspberry Pi Ready**: Pre-built images for ARM devices
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         RedundaNet Network                              │
+│                                                                         │
+│    Your File                                                            │
+│        │                                                                │
+│        ▼                                                                │
+│   ┌─────────┐     Encrypted      ┌─────────┐                           │
+│   │ Encrypt │ ──────────────────►│  Split  │                           │
+│   │  (AES)  │                    │(Erasure)│                           │
+│   └─────────┘                    └────┬────┘                           │
+│                                       │                                 │
+│              ┌────────────────────────┼────────────────────────┐       │
+│              ▼            ▼           ▼           ▼            ▼       │
+│         ┌───────┐    ┌───────┐   ┌───────┐   ┌───────┐    ┌───────┐   │
+│         │Share 1│    │Share 2│   │Share 3│   │  ...  │    │Share10│   │
+│         └───┬───┘    └───┬───┘   └───┬───┘   └───┬───┘    └───┬───┘   │
+│             │            │           │           │            │        │
+│             ▼            ▼           ▼           ▼            ▼        │
+│         ┌───────┐    ┌───────┐   ┌───────┐   ┌───────┐    ┌───────┐   │
+│         │Node A │    │Node B │   │Node C │   │Node D │    │Node E │   │
+│         │ (VPN) │◄──►│ (VPN) │◄─►│ (VPN) │◄─►│ (VPN) │◄──►│ (VPN) │   │
+│         └───────┘    └───────┘   └───────┘   └───────┘    └───────┘   │
+│                                                                         │
+│         Only 3 of 10 shares needed to reconstruct your file            │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+**Key Concepts:**
+- **Your data is encrypted** on your device before upload - nodes cannot read your files
+- **Erasure coding** splits data across nodes - any 3 of 10 nodes can reconstruct your file
+- **Mesh VPN** connects all nodes securely - no central server required
+- **GPG keys** verify node identity - published to public keyservers
+
+## Join the Network
+
+Want to contribute storage and join RedundaNet? Here's how:
+
+### 1. Generate and Publish Your GPG Key
+
+```bash
+# Install the CLI
+pip install redundanet
+
+# Generate a GPG key for your node
+redundanet node keys generate --name my-node --email you@example.com
+
+# Publish your key to public keyservers
+redundanet node keys publish --key-id YOUR_KEY_ID
+```
+
+### 2. Submit Your Application
+
+Visit [redundanet.com/join.html](https://redundanet.com/join.html) and fill out the application form with:
+- Your GPG Key ID
+- Storage contribution (how much space you'll share)
+- Your region
+- Device type
+
+This creates a GitHub issue that's automatically processed.
+
+### 3. Wait for Approval
+
+A maintainer will review your application and merge the PR that adds your node to the network manifest.
+
+### 4. Set Up Your Node
+
+Once approved:
+
+```bash
+# Clone the repository
+git clone https://github.com/adefilippo83/redundanet.git
+cd redundanet
+
+# Initialize your node (use the name assigned to you)
+redundanet init --name node-XXXXXXXX
+
+# Sync the manifest
+redundanet sync
+
+# Start services
+docker compose up -d
+
+# Check status
+redundanet status
+```
+
+## Quick Start (Existing Network Members)
+
+### Prerequisites
+
+- Python 3.11+
+- Docker and Docker Compose
+- GPG (for key management)
+
+### Installation
+
+```bash
+pip install redundanet
+```
+
+### Start Services
+
+```bash
+# As a storage node (contributes storage)
+docker compose --profile storage up -d
+
+# As a client only (uses storage)
+docker compose --profile client up -d
+```
+
+### Upload and Download Files
+
+```bash
+# Upload a file
+redundanet storage upload /path/to/file.txt
+# Returns: URI:CHK:abc123...
+
+# Download a file
+redundanet storage download URI:CHK:abc123... /path/to/output.txt
+```
+
+## CLI Commands
+
+```
+redundanet --help
+
+Commands:
+  init        Initialize a new node
+  status      Show node and network status
+  sync        Sync manifest from repository
+  validate    Validate manifest file
+
+  node        Node management commands
+    list      List all nodes in the network
+    info      Show detailed node information
+    add       Add a new node to manifest
+    remove    Remove a node from manifest
+    keys      Manage GPG keys (generate, export, import, publish, fetch, list)
+
+  network     Network management
+    join      Join an existing network
+    leave     Leave the network
+    peers     Show connected peers
+    vpn       VPN management (start/stop/status)
+
+  storage     Storage management
+    status    Show storage status
+    mount     Mount Tahoe filesystem
+    unmount   Unmount filesystem
+    upload    Upload a file
+    download  Download a file
+```
+
+## Raspberry Pi
+
+Pre-built images are available for Raspberry Pi:
+
+1. Download from [GitHub Releases](https://github.com/adefilippo83/redundanet/releases)
+2. Flash to SD card using Raspberry Pi Imager
+3. Boot and SSH in: `ssh redundanet@redundanet.local` (password: `redundanet`)
+4. Run `redundanet init` to configure
+
+## Architecture
+
+```mermaid
+graph TD
+    subgraph "Your Device"
+        A[redundanet CLI] --> B[Tahoe Client]
+        B --> C[Tinc VPN]
+    end
+
+    subgraph "Network Nodes"
+        D[Tinc VPN] --> E[Tahoe Storage]
+        F[Tinc VPN] --> G[Tahoe Storage]
+        H[Tinc VPN] --> I[Tahoe Introducer]
+    end
+
+    C -->|Encrypted Mesh| D
+    C -->|Encrypted Mesh| F
+    C -->|Encrypted Mesh| H
+```
+
+**Components:**
+- **Tinc VPN**: Creates encrypted mesh network between all nodes
+- **Tahoe-LAFS**: Handles encryption, erasure coding, and distributed storage
+- **GPG**: Authenticates node identity via public keyservers
+- **Manifest**: YAML file in Git defining network configuration
+
+## Documentation
+
+- [Installation Guide](docs/installation.md)
+- [Quick Start Guide](docs/quickstart.md)
+- [Configuration Reference](docs/configuration.md)
+- [Architecture Overview](docs/architecture.md)
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/adefilippo83/redundanet.git
+cd redundanet
+
+# Install dependencies
+make install
+
+# Run tests
+make test
+
+# Run linting
+make lint
+
+# Run type checking
+make type-check
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Run tests (`make test`) and linting (`make lint`)
+5. Commit your changes
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- [Tahoe-LAFS](https://tahoe-lafs.org/) - Distributed storage system
+- [Tinc VPN](https://www.tinc-vpn.org/) - Mesh VPN daemon
+- [Typer](https://typer.tiangolo.com/) - CLI framework
+

{redundanet-2.0.0.dist-info → redundanet-2.0.1.dist-info}/RECORD

@@ -1,23 +1,23 @@
-redundanet/__init__.py,sha256=alb0XFwGxNY-c3R7wZtFBRluszSmqROQ-Vo7Um1F7Xc,398
+redundanet/__init__.py,sha256=tqG349jbZCq9GmU1zT4gYuVUArBzPiJmyf31kzFXqUA,398
 redundanet/__main__.py,sha256=sI1D-Mn0JeICtGPuNLp-uthhIQxOB_6_9Avf1-iOXLQ,151
 redundanet/auth/__init__.py,sha256=BlmLa620gKsRdiD3d8tsDDweA9kI_fTBY9bxM6jtiyU,202
-redundanet/auth/gpg.py,sha256=OG6Gdo19TYzVsyfp9-a8BLxV79gX_P3GcyMe8H_rmh4,9098
+redundanet/auth/gpg.py,sha256=SIhlRrZa5b5FWNVXstsG-jkjm8oY2J0TySPA0QtYDac,9080
 redundanet/auth/keyserver.py,sha256=1zNIOIY62JaAPNWVjZaBHlx2fSN601WsGsR_KizdiAo,6502
 redundanet/cli/__init__.py,sha256=4XqFI3iyLQO6ko2bcSq_OoMvlrk8voMK8twcsHgUziY,89
 redundanet/cli/main.py,sha256=teFau_SP_rb5aDIBNH7vgwcOa8wjXoLW3SoL36kLQZ0,8129
 redundanet/cli/network.py,sha256=K5d03q4t3CBJXEreAQ8WFAsWv2qBhQUIfCE1_1lQcY4,5796
-redundanet/cli/node.py,sha256=z9JyrBdJfpqA7s65_TnyXI_70-7WpH1GlBhG13NfZyM,10161
+redundanet/cli/node.py,sha256=AD9ijvoNKlVY_uR2QQTHrcmnwuetWXj76M1jZ_IOKEE,17230
 redundanet/cli/storage.py,sha256=I-n8NO_x_v7vKp3bx3yxfYNLNHNyOOuXMpl0T4mmZzs,8054
 redundanet/core/__init__.py,sha256=fOx3CxtyI4s2wPmBzAuqkcGq5JLKKS3BvebuUandNBQ,673
 redundanet/core/config.py,sha256=ZlEaR9i1aVHtnWcTE-BHvu3vwpYxd5q0rhlwT6hKh3g,6328
 redundanet/core/exceptions.py,sha256=sCeMw0YU7FFdpZkav5PW64-PTuGUPd2_7TaGlsJh9lY,1835
 redundanet/core/manifest.py,sha256=nW0BEtKEwlh5QQPUCeR8Anya1a8CWJ5-JwBYNW18JBA,12257
 redundanet/core/node.py,sha256=gMtsDVLz1gSZjttoU7jBUQfuQrHV3yDY2ts1yvZL780,4140
-redundanet/network/__init__.py,sha256=8t1sNA9P7xOC_IHN_Tbo0qFakQBTmrriuh-M2fzB41Y,286
+redundanet/network/__init__.py,sha256=Lm17nf722GS1uKgQXAlccnFoFbDNEkoaOP7MwfqwD_U,286
 redundanet/network/discovery.py,sha256=37bu-EL5IKnYHxuup1wBJo3498q9stER-yRX3_6TKlk,6261
 redundanet/network/dns.py,sha256=CneCQldM_QmRaJQJKx3YjygRKktfLjT6y3qJFb48tVc,5305
 redundanet/network/validation.py,sha256=DhjnyknkiCd-FYDz30GcewYC-7lMZCfPGGrBm_DpnPg,8952
-redundanet/storage/__init__.py,sha256=a3e4hfWqY-Gczpi-aMlXEKgQIXAO67K5xc3uBn8I1bI,353
+redundanet/storage/__init__.py,sha256=QDmT9ZP-Fr-DzwUTfe1gkLCxBg86nhoS-F0yRuyYdf8,353
 redundanet/storage/client.py,sha256=FIrgpyZe2ovirvGApk73mtVycZDohuk6Dnnc0KxuCCo,9312
 redundanet/storage/furl.py,sha256=z5s_5344JN6lYRxdt35d7PFL0wtLvBaWdG3Pw4ztLbo,5560
 redundanet/storage/introducer.py,sha256=qhGI3lUOrxCYdx3anF8hFd5efSvDu_JKFPQFBcJI3yM,5483
@@ -25,13 +25,13 @@ redundanet/storage/storage.py,sha256=eedGkr4nr6wUHf4UxMOiI9iyhcq-QEba9qLwEL7kJyY
 redundanet/utils/__init__.py,sha256=gGWh6jgJZLZuRUBKXmIxbMMxsy0B6oU5p63UxUHFcO0,392
 redundanet/utils/files.py,sha256=Mo-_TevoDgVpYo_qMvSLx8CBYXWltz66AOMtIJM6sQA,3761
 redundanet/utils/logging.py,sha256=wvun1z7C2doOCDZHZGYLyW63h5V07TrfS9lH0nOeKOg,2779
-redundanet/utils/process.py,sha256=TZQO9bfwKYOu4OApBEFypiQLyWAenowIu-6HVREACw0,6157
-redundanet/vpn/__init__.py,sha256=MB3Bh4xrCCZUoj1d2BkfbbSbmwL7652lMO76Re6dEjk,283
+redundanet/utils/process.py,sha256=n-M3dscymWN-Q4iijbmBo9cjF--IhAUJ-rGVK6TD-XM,6149
+redundanet/vpn/__init__.py,sha256=wM2iePNDGH-CqsNgnEaEecn6Udrx6DTGnk465vso_sg,283
 redundanet/vpn/keys.py,sha256=yTfLpqguTNOZlsvgzMS4vq9WTgVL9AUVTcZbftY6a3w,5326
 redundanet/vpn/mesh.py,sha256=EVdYcQY2reV_UESXRHEUKEIhhSSwaG7u1vvPtV6PDZI,6041
 redundanet/vpn/tinc.py,sha256=u5j2ZMPOjTfXM4LPHjg7NZmYdTF51kg58qTuA7CDtTw,10288
-redundanet-2.0.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-redundanet-2.0.0.dist-info/METADATA,sha256=x9hHnnwtCPaRwVWw2bGB0SHyUFs2IK6A6huPCpVH7pc,7252
-redundanet-2.0.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-redundanet-2.0.0.dist-info/entry_points.txt,sha256=-0cdQEyYsTHavFdq-k_uws2bxnQrD2Ud0FfllcHGrcw,54
-redundanet-2.0.0.dist-info/RECORD,,
+redundanet-2.0.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+redundanet-2.0.1.dist-info/METADATA,sha256=d21IBlfafMZ66fQT4LmTxIifYxKiFF56hcJzeFrvbFw,10939
+redundanet-2.0.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+redundanet-2.0.1.dist-info/entry_points.txt,sha256=-0cdQEyYsTHavFdq-k_uws2bxnQrD2Ud0FfllcHGrcw,54
+redundanet-2.0.1.dist-info/RECORD,,

redundanet-2.0.0.dist-info/METADATA

@@ -1,265 +0,0 @@
-Metadata-Version: 2.1
-Name: redundanet
-Version: 2.0.0
-Summary: Distributed encrypted storage on a mesh VPN network
-Home-page: https://github.com/alessandrodefilippo/redundanet
-License: MIT
-Keywords: distributed-storage,vpn,encryption,mesh-network,tahoe-lafs
-Author: Alessandro De Filippo
-Author-email: alessandro@example.com
-Requires-Python: >=3.11,<4.0
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Security :: Cryptography
-Classifier: Topic :: System :: Distributed Computing
-Classifier: Topic :: System :: Networking
-Requires-Dist: gitpython (>=3.1,<4.0)
-Requires-Dist: httpx (>=0.26,<0.27)
-Requires-Dist: jinja2 (>=3.1,<4.0)
-Requires-Dist: jsonschema (>=4.21,<5.0)
-Requires-Dist: psutil (>=5.9,<6.0)
-Requires-Dist: pydantic (>=2.5,<3.0)
-Requires-Dist: pydantic-settings (>=2.1,<3.0)
-Requires-Dist: python-gnupg (>=0.5,<0.6)
-Requires-Dist: pyyaml (>=6.0,<7.0)
-Requires-Dist: rich (>=13.7,<14.0)
-Requires-Dist: structlog (>=24.1,<25.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
-Requires-Dist: watchdog (>=4.0,<5.0)
-Project-URL: Documentation, https://redundanet.readthedocs.io
-Project-URL: Repository, https://github.com/alessandrodefilippo/redundanet
-Description-Content-Type: text/markdown
-
-# RedundaNet - Distributed Encrypted Storage Network
-
-RedundaNet is a distributed, encrypted storage system built on a secure mesh VPN network. It enables users to contribute storage resources to a collective grid while maintaining privacy through end-to-end encryption.
-
-## Features
-
-- **Decentralized Architecture**: No central authority or single point of failure
-- **End-to-End Encryption**: Data is encrypted before leaving the user's device using Tahoe-LAFS
-- **GPG-Based Authentication**: Secure node identity verification
-- **Private Networking**: Secure Tinc mesh VPN isolates the storage network from the public internet
-- **Erasure Coding**: Data is split and distributed across multiple nodes (3-of-10 scheme by default)
-- **Resource Sharing**: Users contribute resources and benefit from the collective capacity
-- **Containerized Deployment**: Easy setup with Docker Compose
-- **Python-Based CLI**: Modern CLI with Typer for easy management
-
-## Architecture
-
-```mermaid
-graph TD
-    subgraph "User Node"
-        A[redundanet CLI] --> B[Tahoe Client]
-        B --> C[Tinc VPN]
-    end
-
-    subgraph "Storage Node 1"
-        D[Tinc VPN] --> E[Tahoe Storage]
-        E --> F[Local Storage]
-    end
-
-    subgraph "Storage Node 2"
-        G[Tinc VPN] --> H[Tahoe Storage]
-        H --> I[Local Storage]
-    end
-
-    subgraph "Introducer Node"
-        J[Tinc VPN] --> K[Tahoe Introducer]
-    end
-
-    C -->|Encrypted VPN| D
-    C -->|Encrypted VPN| G
-    C -->|Encrypted VPN| J
-
-    K -.->|Introduction Services| B
-    K -.->|Introduction Services| E
-    K -.->|Introduction Services| H
-```
-
-## Quick Start
-
-### Prerequisites
-
-- Python 3.11+
-- Docker and Docker Compose
-- GPG (for key management)
-
-### Installation
-
-#### Using pip (recommended)
-
-```bash
-pip install redundanet
-```
-
-#### Using Poetry (for development)
-
-```bash
-git clone https://github.com/adefilippo83/project-earthgrid.git
-cd project-earthgrid
-poetry install
-```
-
-### Initialize a Node
-
-```bash
-# Interactive setup
-redundanet init
-
-# Or with options
-redundanet init --node-name my-node --vpn-ip 10.100.0.10
-```
-
-### Start Services with Docker
-
-```bash
-# Start as a storage node
-docker compose -f docker/docker-compose.yml --profile storage up -d
-
-# Start as a client only
-docker compose -f docker/docker-compose.yml --profile client up -d
-
-# Start as an introducer (network coordinator)
-docker compose -f docker/docker-compose.yml --profile introducer up -d
-```
-
-### Check Status
-
-```bash
-redundanet status
-```
-
-## CLI Commands
-
-```
-redundanet --help
-
-Commands:
-  init        Initialize a new node
-  status      Show node and network status
-  sync        Sync manifest from repository
-  validate    Validate manifest file
-
-  node        Node management commands
-    list      List all nodes in the network
-    info      Show detailed node information
-    add       Add a new node to manifest
-    remove    Remove a node from manifest
-
-  network     Network management
-    join      Join an existing network
-    leave     Leave the network
-    peers     Show connected peers
-    vpn       VPN management (start/stop/status)
-
-  storage     Storage management
-    status    Show storage status
-    mount     Mount Tahoe filesystem
-    unmount   Unmount filesystem
-    upload    Upload a file
-    download  Download a file
-```
-
-## Configuration
-
-RedundaNet uses a YAML manifest file to define network configuration:
-
-```yaml
-network:
-  name: my-network
-  version: "1.0.0"
-  domain: redundanet.local
-  vpn_network: 10.100.0.0/16
-
-tahoe:
-  shares_needed: 3
-  shares_happy: 7
-  shares_total: 10
-  introducer_furl: pb://...
-
-nodes:
-  - name: node1
-    internal_ip: 192.168.1.10
-    vpn_ip: 10.100.0.1
-    public_ip: 1.2.3.4
-    gpg_key_id: ABCD1234
-    roles: [introducer, storage]
-    storage_contribution: 500GB
-```
-
-## Development
-
-### Setup Development Environment
-
-```bash
-# Clone repository
-git clone https://github.com/adefilippo83/project-earthgrid.git
-cd project-earthgrid
-
-# Install dependencies
-make install
-
-# Run tests
-make test
-
-# Run linting
-make lint
-
-# Run type checking
-make type-check
-```
-
-### Project Structure
-
-```
-redundanet/
-├── src/redundanet/          # Main Python package
-│   ├── cli/                 # Typer CLI commands
-│   ├── core/                # Core business logic
-│   ├── vpn/                 # Tinc VPN management
-│   ├── storage/             # Tahoe-LAFS integration
-│   ├── auth/                # GPG authentication
-│   ├── network/             # Network utilities
-│   └── utils/               # Shared utilities
-├── docker/                  # Docker configurations
-├── tests/                   # Test suite
-├── docs/                    # Documentation
-└── manifests/               # Example manifests
-```
-
-## Documentation
-
-- [Installation Guide](docs/installation.md)
-- [Quick Start Guide](docs/quickstart.md)
-- [Configuration Reference](docs/configuration.md)
-- [Architecture Overview](docs/architecture.md)
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Make your changes
-4. Run tests (`make test`)
-5. Run linting (`make lint`)
-6. Commit your changes (`git commit -m 'Add amazing feature'`)
-7. Push to the branch (`git push origin feature/amazing-feature`)
-8. Open a Pull Request
-
-## License
-
-This project is licensed under the GPL License - see the [LICENSE](LICENSE) file for details.
-
-## Acknowledgments
-
-- [Tahoe-LAFS](https://tahoe-lafs.org/) - Distributed storage system
-- [Tinc VPN](https://www.tinc-vpn.org/) - Mesh VPN daemon
-- [Typer](https://typer.tiangolo.com/) - CLI framework
-