stashify 0.1.0__py3-none-any.whl

stash/__init__.py

@@ -0,0 +1,5 @@
+"""Stash - Privacy-focused CLI storage system."""
+
+__version__ = "0.1.0"
+__author__ = "Stash Contributors"
+__license__ = "MIT"

stash/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Stash CLI package."""
+
+from stash.cli.main import main
+
+__all__ = ["main"]

stash/cli/commands/__init__.py

@@ -0,0 +1,23 @@
+"""CLI commands package."""
+
+from stash.cli.commands.get import get_commands
+from stash.cli.commands.info import info_commands
+from stash.cli.commands.init import init_commands
+from stash.cli.commands.ls import ls_commands
+from stash.cli.commands.provider import provider_commands
+from stash.cli.commands.put import put_commands
+from stash.cli.commands.rm import rm_commands
+from stash.cli.commands.status import status_commands
+from stash.cli.commands.verify import verify_commands
+
+__all__ = [
+    "init_commands",
+    "provider_commands",
+    "put_commands",
+    "get_commands",
+    "ls_commands",
+    "info_commands",
+    "rm_commands",
+    "verify_commands",
+    "status_commands",
+]

stash/cli/commands/get.py

@@ -0,0 +1,160 @@
+"""CLI command: get - Retrieve a file."""
+
+import asyncio
+from pathlib import Path
+
+import click
+
+from stash.cli.output import create_progress, format_size, print_error, print_info, print_success
+from stash.core.crypto import CryptoEngine, EncryptionConfig
+from stash.core.metadata import MetadataStore
+from stash.providers import ProviderRegistry
+
+
+@click.command()
+@click.argument("file_id_or_name")
+@click.option("--output", "-o", type=click.Path(path_type=Path), help="Output path (default: current directory)")
+@click.option("--password", prompt=True, hide_input=True, help="Encryption password")
+@click.option("--overwrite", is_flag=True, help="Overwrite existing file")
+@click.pass_context
+def get_cmd(ctx: click.Context, file_id_or_name: str, output: Path | None, password: str, overwrite: bool) -> None:
+    """Retrieve a file from Stash."""
+    asyncio.run(_get_async(file_id_or_name, ctx.obj["repo"], output, password, overwrite))
+
+
+async def _get_async(
+    file_id_or_name: str,
+    repo_path: Path,
+    output: Path | None,
+    password: str,
+    overwrite: bool,
+) -> None:
+    repo = repo_path.resolve()
+    store = MetadataStore(repo)
+
+    file_id = _resolve_file_id(store, file_id_or_name)
+    if not file_id:
+        print_error(f"File not found: {file_id_or_name}")
+        return
+
+    manifest = store.load_manifest(file_id)
+
+    # Decrypt filename
+    crypto = CryptoEngine()
+    enc_config = EncryptionConfig(
+        algorithm=manifest.encryption.algorithm,
+        key_size=manifest.encryption.key_size,
+        nonce_size=manifest.encryption.nonce_size,
+        chunk_key_derivation=manifest.encryption.chunk_key_derivation,
+    )
+    file_key = None
+    try:
+        if manifest.encryption.file_key_wrapped:
+            from stash.core.crypto import FileKey
+            file_key = FileKey(
+                key=crypto.decrypt_file_key(
+                    manifest.encryption.file_key_wrapped,
+                    password,
+                    enc_config
+                ).key,
+                salt=manifest.encryption.file_key_salt,
+                config=enc_config
+            )
+        else:
+            print_error("File key not wrapped - cannot decrypt")
+            return
+    except Exception as e:
+        print_error(f"Failed to decrypt file key: {e}")
+        return
+
+    # Decrypt filename
+    from stash.core.crypto import EncryptedChunk
+    encrypted_name_bytes = bytes.fromhex(manifest.encrypted_name)
+    encrypted_name_chunk = EncryptedChunk(
+        ciphertext=encrypted_name_bytes,
+        nonce=manifest.encrypted_name_nonce,
+        chunk_index=-1,
+    )
+    try:
+        decrypted_name = crypto.decrypt_chunk(encrypted_name_chunk, file_key).decode()
+    except Exception as e:
+        print_error(f"Failed to decrypt filename: {e}")
+        return
+
+    if output is None:
+        output_path = Path.cwd() / decrypted_name
+    elif output.is_dir():
+        output_path = output / decrypted_name
+    else:
+        output_path = output
+
+    if output_path.exists() and not overwrite:
+        print_error(f"File exists: {output_path}. Use --overwrite to replace.")
+        return
+
+    providers_config = {}
+    for chunk in manifest.chunks:
+        if chunk.provider not in providers_config:
+            config = store.get_provider_config(chunk.provider)
+            if config:
+                providers_config[chunk.provider] = config
+
+    provider_instances = {}
+    for name, config in providers_config.items():
+        instance = await ProviderRegistry.create(config.type, config)
+        provider_instances[name] = instance
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    progress = create_progress()
+    task = progress.add_task("Downloading", total=manifest.chunk_count)
+
+    with progress, output_path.open("wb") as f:
+        for chunk_info in sorted(manifest.chunks, key=lambda c: c.index):
+            provider = provider_instances.get(chunk_info.provider)
+            if not provider:
+                print_error(f"Provider not available: {chunk_info.provider}")
+                return
+
+            remote_ref = type('RemoteRef', (), {
+                'provider': chunk_info.provider,
+                'remote_id': chunk_info.remote_id,
+                'metadata': chunk_info.metadata
+            })()
+
+            encrypted_data = await provider.download_chunk(remote_ref)
+
+            from stash.core.crypto import EncryptedChunk
+            encrypted_chunk = EncryptedChunk(
+                ciphertext=encrypted_data,
+                nonce=chunk_info.nonce,
+                chunk_index=chunk_info.index,
+            )
+
+            try:
+                decrypted = crypto.decrypt_chunk(encrypted_chunk, file_key)
+                f.write(decrypted)
+                progress.advance(task)
+            except Exception as e:
+                print_error(f"Decryption failed for chunk {chunk_info.index}: {e}")
+                return
+
+    for instance in provider_instances.values():
+        await instance.close()
+
+    print_success(f"Retrieved '{decrypted_name}' to {output_path}")
+    print_info(f"Size: {format_size(manifest.original_size)}")
+
+
+def _resolve_file_id(store: MetadataStore, identifier: str) -> str | None:
+    """Resolve file ID or name to file ID."""
+    if store.file_exists(identifier):
+        return identifier
+    for fid in store.list_files():
+        manifest = store.load_manifest(fid)
+        if manifest.original_name == identifier:
+            return fid
+    return None
+
+
+get_commands = get_cmd

stash/cli/commands/info.py

@@ -0,0 +1,45 @@
+"""CLI command: info - Show file metadata."""
+
+
+import click
+
+from stash.cli.output import print_error, print_file_info
+from stash.core.metadata import MetadataStore
+
+
+@click.command()
+@click.argument("file_id_or_name")
+@click.pass_context
+def info_cmd(ctx: click.Context, file_id_or_name: str) -> None:
+    """Show detailed file metadata."""
+    repo = ctx.obj["repo"].resolve()
+    store = MetadataStore(repo)
+
+    file_id = _resolve_file_id(store, file_id_or_name)
+    if not file_id:
+        print_error(f"File not found: {file_id_or_name}")
+        return
+
+    manifest = store.load_manifest(file_id)
+
+    providers = {}
+    for name in store.list_providers():
+        config = store.get_provider_config(name)
+        if config:
+            providers[name] = config
+
+    print_file_info(manifest, providers)
+
+
+def _resolve_file_id(store: MetadataStore, identifier: str) -> str | None:
+    """Resolve file ID or name to file ID."""
+    if store.file_exists(identifier):
+        return identifier
+    for fid in store.list_files():
+        manifest = store.load_manifest(fid)
+        if manifest.original_name == identifier:
+            return fid
+    return None
+
+
+info_commands = info_cmd

stash/cli/commands/init.py

@@ -0,0 +1,34 @@
+"""CLI command: init - Initialize a new Stash repository."""
+
+
+import click
+
+from stash.cli.output import print_error, print_info, print_success
+from stash.core.metadata import MetadataStore
+
+
+@click.command()
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing repository")
+@click.pass_context
+def init_cmd(ctx: click.Context, force: bool) -> None:
+    """Initialize a new Stash repository."""
+    repo_path = ctx.obj["repo"]
+    metadata_dir = repo_path / ".stash" / "metadata"
+
+    if metadata_dir.exists() and not force:
+        print_error(f"Repository already exists at {repo_path}")
+        print_info("Use --force to overwrite")
+        return
+
+    store = MetadataStore(repo_path)
+    store.save_config({
+        "version": 1,
+        "created_at": __import__("time").time(),
+        "providers": {},
+    })
+
+    print_success(f"Initialized Stash repository at {repo_path}")
+    print_info("Add a provider with: stash provider add discord")
+
+
+init_commands = init_cmd

stash/cli/commands/ls.py

@@ -0,0 +1,41 @@
+"""CLI command: ls - List stored files."""
+
+
+import click
+
+from stash.cli.output import format_size, format_timestamp, print_info, print_table
+from stash.core.metadata import MetadataStore
+
+
+@click.command()
+@click.option("--long", "-l", is_flag=True, help="Show detailed information")
+@click.pass_context
+def ls_cmd(ctx: click.Context, long: bool) -> None:
+    """List stored files."""
+    repo = ctx.obj["repo"].resolve()
+    store = MetadataStore(repo)
+
+    files = store.list_files()
+    if not files:
+        print_info("No files stored")
+        return
+
+    if long:
+        rows = []
+        for fid in files:
+            manifest = store.load_manifest(fid)
+            rows.append([
+                fid[:16],
+                manifest.original_name,
+                format_size(manifest.original_size),
+                str(manifest.chunk_count),
+                format_timestamp(manifest.created_at),
+            ])
+        print_table("Stored Files", ["File ID", "Name", "Size", "Chunks", "Created"], rows)
+    else:
+        for fid in files:
+            manifest = store.load_manifest(fid)
+            print_info(f"{fid[:16]}  {manifest.original_name}  ({format_size(manifest.original_size)})")
+
+
+ls_commands = ls_cmd

stash/cli/commands/provider.py

@@ -0,0 +1,124 @@
+"""CLI commands for provider management."""
+
+
+import click
+
+from stash.cli.output import confirm, print_error, print_info, print_success
+from stash.core.metadata import MetadataStore
+from stash.core.storage import ProviderConfig
+from stash.providers import ProviderRegistry
+
+
+@click.command()
+@click.argument("name")
+@click.option("--type", "provider_type", type=click.Choice(["discord", "telegram"]), help="Provider type")
+@click.option("--token", prompt=True, hide_input=True, help="Bot token")
+@click.option("--channel-id", help="Discord channel ID for storage")
+@click.option("--chat-id", help="Telegram chat ID for storage")
+@click.option("--is-bot/--is-user", default=True, help="Discord: token type (default: bot)")
+@click.option("--max-concurrent", default=3, help="Max concurrent uploads")
+@click.pass_context
+def provider_add_cmd(
+    ctx: click.Context,
+    name: str,
+    provider_type: str | None,
+    token: str,
+    channel_id: str | None,
+    chat_id: str | None,
+    is_bot: bool,
+    max_concurrent: int,
+) -> None:
+    """Add a storage provider."""
+    repo_path = ctx.obj["repo"]
+    store = MetadataStore(repo_path)
+
+    if name in store.list_providers():
+        print_error(f"Provider '{name}' already exists")
+        return
+
+    if provider_type is None:
+        provider_type = name.lower()
+
+    if provider_type not in ProviderRegistry.list_providers():
+        print_error(f"Unknown provider type: {provider_type}")
+        print_info(f"Available types: {', '.join(ProviderRegistry.list_providers())}")
+        return
+
+    credentials: dict[str, str] = {"token": token}
+    if provider_type == "discord":
+        if not channel_id:
+            channel_id = click.prompt("Discord channel ID", type=str)
+        credentials["channel_id"] = channel_id
+        credentials["is_bot"] = str(is_bot).lower()
+    elif provider_type == "telegram":
+        if not chat_id:
+            chat_id = click.prompt("Telegram chat ID", type=str)
+        credentials["chat_id"] = chat_id
+
+    config = ProviderConfig(
+        name=name,
+        type=provider_type,
+        credentials=credentials,
+        settings={
+            "max_concurrent": str(max_concurrent),
+        },
+    )
+
+    store.set_provider_config(name, config)
+    print_success(f"Added provider '{name}' ({provider_type})")
+
+
+@click.command(name="list")
+@click.pass_context
+def provider_list_cmd(ctx: click.Context) -> None:
+    """List configured providers."""
+    repo_path = ctx.obj["repo"]
+    store = MetadataStore(repo_path)
+
+    providers = store.list_providers()
+    if not providers:
+        print_info("No providers configured")
+        print_info("Add one with: stash provider add --type discord <name>")
+        return
+
+    from stash.cli.output import print_table
+    rows = []
+    for name in providers:
+        config = store.get_provider_config(name)
+        ptype = config.type if config else "unknown"
+        if ptype == "discord":
+            channel = config.credentials.get("channel_id", "unknown") if config else "unknown"
+        elif ptype == "telegram":
+            channel = config.credentials.get("chat_id", "unknown") if config else "unknown"
+        else:
+            channel = "unknown"
+        rows.append([name, ptype, channel])
+    print_table("Configured Providers", ["Name", "Type", "Channel/Chat ID"], rows)
+
+
+@click.command()
+@click.argument("name")
+@click.option("--force", "-f", is_flag=True, help="Force removal")
+@click.pass_context
+def provider_remove_cmd(ctx: click.Context, name: str, force: bool) -> None:
+    """Remove a storage provider."""
+    repo_path = ctx.obj["repo"]
+    store = MetadataStore(repo_path)
+
+    if name not in store.list_providers():
+        print_error(f"Provider '{name}' not found")
+        return
+
+    if not force and not confirm(f"Remove provider '{name}'?"):
+        print_info("Cancelled")
+        return
+
+    store.remove_provider_config(name)
+    print_success(f"Removed provider '{name}'")
+
+
+provider_commands = click.Group("provider", commands={
+    "add": provider_add_cmd,
+    "list": provider_list_cmd,
+    "remove": provider_remove_cmd,
+})

stash/cli/commands/put.py

@@ -0,0 +1,185 @@
+"""CLI command: put - Store a file."""
+
+import asyncio
+from pathlib import Path
+
+import click
+
+from stash.cli.output import confirm as confirm_prompt
+from stash.cli.output import create_progress, format_size, print_error, print_info, print_success
+from stash.core.chunking import ChunkConfig, Chunker
+from stash.core.crypto import CryptoEngine
+from stash.core.jobs import JobConfig
+from stash.core.manifest import (
+    DistributionStrategy,
+    EncryptionInfo,
+    ManifestBuilder,
+    compute_checksum,
+    generate_file_id,
+)
+from stash.core.metadata import MetadataStore
+from stash.providers import ProviderRegistry
+
+
+@click.command()
+@click.argument("file_path", type=click.Path(exists=True, path_type=Path))
+@click.option("--provider", help="Specific provider to use (default: first available)")
+@click.option("--chunk-size", type=int, help="Chunk size in bytes (default: provider limit)")
+@click.option("--strategy", type=click.Choice(["single", "split", "balanced", "replicated"]), default="single", help="Distribution strategy")
+@click.option("--password", prompt=True, hide_input=True, help="Encryption password")
+@click.option("--confirm/--no-confirm", default=True, help="Confirm before upload")
+@click.pass_context
+def put_cmd(ctx: click.Context, file_path: Path, provider: str | None, chunk_size: int | None, strategy: str, password: str, confirm: bool) -> None:
+    """Store a file in Stash."""
+    asyncio.run(_put_async(file_path, ctx.obj["repo"], provider, chunk_size, strategy, password, confirm))
+
+
+async def _put_async(
+    file_path: Path,
+    repo_path: Path,
+    provider_name: str | None,
+    chunk_size: int | None,
+    strategy: str,
+    password: str,
+    do_confirm: bool,
+) -> None:
+    repo = repo_path.resolve()
+    store = MetadataStore(repo)
+
+    providers = store.list_providers()
+    if not providers:
+        print_error("No providers configured. Run: stash provider add discord")
+        return
+
+    if provider_name:
+        if provider_name not in providers:
+            print_error(f"Provider '{provider_name}' not found")
+            return
+        provider_names = [provider_name]
+    else:
+        provider_names = providers
+
+    if not file_path.exists():
+        print_error(f"File not found: {file_path}")
+        return
+
+    file_size = file_path.stat().st_size
+    if file_size == 0:
+        print_error("Cannot store empty file")
+        return
+
+    if do_confirm and not confirm_prompt(f"Store '{file_path.name}' ({format_size(file_size)})?"):
+        print_info("Cancelled")
+        return
+
+    crypto = CryptoEngine()
+    file_key = crypto.generate_file_key()
+    wrapped_key = crypto.encrypt_file_key(file_key, password)
+
+    # Encrypt the filename
+    encrypted_name_chunk = crypto.encrypt_chunk(file_path.name.encode(), file_key, -1)
+    encrypted_name = encrypted_name_chunk.ciphertext.hex()
+    encrypted_name_nonce = encrypted_name_chunk.nonce
+
+    provider_configs = {}
+    for name in provider_names:
+        config = store.get_provider_config(name)
+        if not config:
+            print_error(f"Provider config not found: {name}")
+            return
+        provider_configs[name] = config
+
+    provider_instances = {}
+    for name, config in provider_configs.items():
+        instance = await ProviderRegistry.create(config.type, config)
+        provider_instances[name] = instance
+
+    limits = {name: p.get_limits() for name, p in provider_instances.items()}
+    max_chunk = min(l.max_chunk_size for l in limits.values())
+    effective_chunk_size = min(chunk_size or max_chunk, max_chunk)
+
+    chunker = Chunker(ChunkConfig(chunk_size=effective_chunk_size))
+    num_chunks = chunker.get_num_chunks(file_size)
+
+    dist_strategy = DistributionStrategy(strategy)
+
+    encryption_info = EncryptionInfo(
+        algorithm="AES-256-GCM",
+        key_size=32,
+        nonce_size=12,
+        chunk_key_derivation="HKDF-SHA256",
+        file_key_salt=file_key.salt,
+        file_key_wrapped=wrapped_key,
+    )
+
+    builder = ManifestBuilder(
+        file_id=generate_file_id(),
+        original_name=file_path.name,
+        encrypted_name=encrypted_name,
+        encrypted_name_nonce=encrypted_name_nonce,
+        original_size=file_size,
+        chunk_size=effective_chunk_size,
+        encryption=encryption_info,
+        strategy=dist_strategy,
+    )
+
+    print_info(f"Processing {num_chunks} chunks ({format_size(effective_chunk_size)} each)...")
+
+    JobConfig(max_workers=min(4, num_chunks))
+
+    semaphores = {name: asyncio.Semaphore(int(p.config.settings.get("max_concurrent", "3"))) for name, p in provider_instances.items()}
+
+    progress = create_progress()
+    task = progress.add_task("Uploading", total=num_chunks)
+
+    from stash.core.chunking import Chunk
+
+    async def upload_chunk(chunk: Chunk, provider_name: str) -> None:
+        async with semaphores[provider_name]:
+            # Use opaque identifier: file_id + chunk index (no filename)
+            remote_path = f"{builder.file_id}/chunk-{chunk.index:06d}"
+            remote_ref = await provider_instances[provider_name].upload_chunk(chunk, remote_path)
+            checksum = compute_checksum(chunk.data)
+            builder.add_chunk(
+                index=chunk.index,
+                size=chunk.size,
+                encrypted_size=len(remote_ref.metadata.get("size", "0")),
+                checksum=checksum,
+                provider=provider_name,
+                remote_id=remote_ref.remote_id,
+                nonce=encrypted.nonce,
+                metadata=remote_ref.metadata,
+            )
+            progress.advance(task)
+
+    with progress:
+        for chunk in chunker.chunk_file(file_path):
+            encrypted = crypto.encrypt_chunk(chunk.data, file_key, chunk.index)
+            encrypted_chunk = type(chunk)(
+                index=chunk.index,
+                data=encrypted.ciphertext,
+                offset=chunk.offset,
+                size=len(encrypted.ciphertext),
+                is_last=chunk.is_last,
+            )
+
+            if dist_strategy == DistributionStrategy.SINGLE:
+                target = provider_names[0]
+            elif dist_strategy == DistributionStrategy.SPLIT:
+                target = provider_names[chunk.index % len(provider_names)]
+            else:
+                target = provider_names[0]
+
+            await upload_chunk(encrypted_chunk, target)
+
+    manifest = builder.build()
+    store.save_manifest(manifest)
+
+    for instance in provider_instances.values():
+        await instance.close()
+
+    print_success(f"Stored '{file_path.name}' as {manifest.file_id}")
+    print_info(f"Chunks: {manifest.chunk_count}, Size: {format_size(manifest.original_size)}")
+
+
+put_commands = put_cmd