# hoody-files Subskill ## Overview ### Purpose hoody-files provides universal file access across local storage and 60+ cloud storage providers. Every file path is a URL. This service unifies file management, cloud storage connections, archive handling, downloads, and advanced file operations under a single interface. It supports local files, remote backends (S3, Azure, Google Drive, Dropbox, FTP, SSH, WebDAV, and 60+ others), archive manipulation, image processing, file journaling, and FUSE mounts. ### When to Use Use hoody-files when you need to: - Upload, download, list, or manage files and directories - Connect to or manage cloud storage backends (S3, Azure, Google Drive, Dropbox, etc.) - Extract, preview, or create archives (ZIP, TAR, compressed TAR) - Download files from remote URLs - Search file contents or find files by pattern - Monitor file mutations via journal - Create persistent FUSE mounts for remote storage - Process and convert images - Copy, move, rename, or change file permissions ### Authentication Model All hoody-files operations run inside a container. Authentication uses: - **Container targeting**: Every command requires `-c ` or `HOODY_CONTAINER` env var - **API authentication**: `hoody auth login`, `--token `, or `HOODY_TOKEN` env var - **Output control**: Use `-o json` for machine-readable output ### Philosophy Integration hoody-files embodies Hoody's universal access philosophy: every file path is a URL, and local storage is just another backend. The service abstracts 60+ cloud providers into a unified interface so you can manage all files through consistent CLI commands regardless of where they reside. --- ## Core Resource Workflows ### File Listing and Metadata #### List Directory Contents List files in a directory within a container. Returns directory listing as JSON when using CLI. ``` # List files in root directory hoody files get / -c mycontainer # List files in a subdirectory hoody files get /documents -c mycontainer # List with JSON output hoody files get /documents -c mycontainer -o json ``` #### Get File Metadata (stat) Retrieve detailed metadata for a single file or directory without downloading content. ``` # Get file metadata hoody files stat /documents/report.pdf -c mycontainer # JSON output hoody files stat /documents/report.pdf -c mycontainer -o json ``` Response fields include: name, type, size, modification time, permissions, ownership, symlink information. #### Get File Headers (HEAD) Retrieve metadata headers for a file. ``` # Get file headers hoody files metadata /documents/report.pdf -c mycontainer ``` #### Get Allowed Methods (OPTIONS) Discover supported HTTP methods and WebDAV capabilities for a path. ``` # Get allowed methods hoody files options /documents -c mycontainer ``` --- ### File Upload and Creation #### Upload File Upload a file to the server. Creates new files or overwrites existing ones. ``` # Upload a file hoody files put /uploads/data.csv -c mycontainer # Upload with overwrite hoody files put /uploads/data.csv -c mycontainer ``` #### Append to File Append binary data to the end of an existing file. Creates the file if it does not exist. Auto-creates parent directories. ``` # Append data to file hoody files append /logs/app.log -c mycontainer ``` #### Touch File Create an empty file if it does not exist, or update the modification time if it does. Cannot be used on directories. ``` # Create empty file or update mtime hoody files touch /uploads/newfile.txt -c mycontainer ``` --- ### File Modification #### Modify File Properties Modify file properties via PATCH. Supports chmod, chown, rename, and cross-directory move. ``` # Change permissions via modify-properties hoody files modify-properties /documents/report.pdf -c mycontainer # Change ownership via modify-properties hoody files modify-properties /documents/report.pdf -c mycontainer ``` #### Change File Permissions (chmod) Change file or directory permissions using octal mode (Unix only). ``` # Set permissions to 755 hoody files chmod /scripts/run.sh -c mycontainer ``` #### Change File Ownership (chown) Change file or directory ownership (Unix only). ``` # Set owner and group hoody files chown /scripts/run.sh -c mycontainer ``` #### Patch File Generic PATCH operation for file modifications. ``` # Patch file properties hoody files patch /documents/report.pdf -c mycontainer ``` --- ### File Copy, Move, and Delete #### Copy File or Directory Copy a file or directory to a new location. Supports recursive directory copy. Auto-creates parent directories at destination. ``` # Copy file hoody files copy /documents/report.pdf -c mycontainer # Copy directory recursively hoody files copy /documents/archive -c mycontainer ``` #### Move File or Directory Move or rename a file/directory to a new location. Works across directories. Auto-creates parent directories at destination. ``` # Move file to new location hoody files move /documents/report.pdf -c mycontainer # Rename file in place hoody files move /documents/old-name.pdf -c mycontainer ``` #### Delete File or Directory Permanently delete a file or directory. Requires confirmation with `--yes`. ``` # Delete a file (requires confirmation) hoody files delete /documents/old-report.pdf --yes -c mycontainer # Delete recursively (requires confirmation) hoody files delete-recursive /documents/archive --yes -c mycontainer ``` --- ### File Search and Query #### Glob Search Find files and directories matching a glob pattern. Supports recursive patterns (`**/*.rs`), brace expansion (`{ts,tsx}`), character classes (`[a-z]`), and standard wildcards (`*`). ``` # Find all PDF files recursively hoody files glob /documents/**/*.pdf -c mycontainer # Find TypeScript and JavaScript files hoody files glob /src/**/*.{ts,tsx,js,jsx} -c mycontainer ``` #### Grep Search Search file or directory contents using regex patterns. Powered by ripgrep engine with .gitignore support. ``` # Search for pattern in files hoody files grep /src -c mycontainer # Search with JSON output hoody files grep /src -c mycontainer -o json ``` #### Search Directory Search for files matching a query within a directory. ``` # Search directory for files hoody files search /documents -c mycontainer ``` --- ### Path Resolution #### Resolve Canonical Path (realpath) Resolve a file or directory path to its canonical absolute form by following all symbolic links and resolving `.`/`..` segments. ``` # Resolve path hoody files realpath /documents/../shared/report.pdf -c mycontainer ``` --- ### Service Health #### Health Check Standard service health endpoint. Returns service identity, build and start timestamps, resource usage, and caller metadata. ``` # Check service health hoody files health -c mycontainer # JSON output hoody files health -c mycontainer -o json ``` #### API Version Returns the current API version and server information. ``` # Get API version hoody files version -c mycontainer ``` --- ### Backends Management #### List All Backends Get list of all connected backends. ``` # List all backends hoody files list -c mycontainer # JSON output hoody files list -c mycontainer -o json ``` #### Get Backend Details Get detailed information about a specific backend. ``` # Get backend by ID hoody files get -c mycontainer # JSON output hoody files get -c mycontainer -o json ``` #### Update Backend Credentials Rotate credentials (passwords, tokens, OAuth refresh tokens, S3 keys, passphrases) for an existing backend connection. Identity fields (host, user, port, type) cannot be changed. ``` # Update backend credentials hoody files update -c mycontainer ``` #### Test Backend Connection Verify that a backend connection is working. ``` # Test backend connection hoody files test -c mycontainer ``` #### Disconnect Backend Remove a backend connection. ``` # Disconnect backend hoody files disconnect -c mycontainer ``` --- ### Backend Providers #### Connect Alias Backend Connect to an alias (path shortcut) backend. ``` # Connect alias backend hoody files alias -c mycontainer ``` Request body must include `remote` field: the remote or path to alias (e.g., `myremote:path/to/dir`). #### Connect B2 Backend Connect to Backblaze B2 storage. ``` # Connect B2 backend hoody files b2 -c mycontainer ``` Request body must include: - `account`: string - Account ID or Application Key ID - `key`: string - Application Key #### Connect Cache Backend Connect to a cache wrapper for another remote. ``` # Connect cache backend hoody files cache -c mycontainer ``` Request body must include `remote` field: remote to cache (must contain a `:` and path). #### Connect Chunker Backend Connect to a chunker backend for transparent file chunking/splitting. ``` # Connect chunker backend hoody files chunker -c mycontainer ``` Request body must include `remote` field: remote to chunk/unchunk. #### Connect Cloudinary Backend Connect to Cloudinary image/video management. ``` # Connect cloudinary backend hoody files cloudinary -c mycontainer ``` Request body must include: - `api_key`: string - Cloudinary API Key - `api_secret`: string - Cloudinary API Secret - `cloud_name`: string - Cloudinary Environment Name #### Connect Combine Backend Combine several remotes into one. ``` # Connect combine backend hoody files combine -c mycontainer ``` Request body must include `upstreams` field: upstreams for combining in form `dir1: dir2:`. #### Connect Compress Backend Connect to a compress wrapper for another remote. ``` # Connect compress backend hoody files compress -c mycontainer ``` Request body must include `remote` field: remote to compress. #### Connect Crypt Backend Connect to an encrypted remote. ``` # Connect crypt backend hoody files crypt -c mycontainer ``` Request body must include: - `password`: string - Password or passphrase for encryption - `remote`: string - Remote to encrypt/decrypt (must contain `:` and path) #### Connect File Fabric Backend Connect to Enterprise File Fabric. ``` # Connect filefabric backend hoody files filefabric -c mycontainer ``` Request body must include `url` field: URL of the Enterprise File Fabric to connect to. #### Connect FTP Backend Connect to an FTP server. ``` # Connect FTP backend hoody files ftp -c mycontainer ``` Request body must include `host` field: FTP host to connect to (e.g., `ftp.example.com`). #### Connect Azure Blob Backend Connect to Azure Blob Storage. ``` # Connect azureblob backend hoody files azureblob -c mycontainer ``` #### Connect Azure Files Backend Connect to Azure Files. ``` # Connect azurefiles backend hoody files azurefiles -c mycontainer ``` #### Connect Box Backend Connect to Box storage. ``` # Connect box backend hoody files box -c mycontainer ``` #### Connect Drive Backend Connect to Google Drive. ``` # Connect Google Drive backend hoody files drive -c mycontainer ``` #### Connect Dropbox Backend Connect to Dropbox. ``` # Connect Dropbox backend hoody files dropbox -c mycontainer ``` #### Connect Fichier Backend Connect to 1Fichier. ``` # Connect fichier backend hoody files fichier -c mycontainer ``` #### Connect Files.com Backend Connect to Files.com. ``` # Connect filescom backend hoody files filescom -c mycontainer ``` #### Connect Gofile Backend Connect to Gofile. ``` # Connect gofile backend hoody files gofile -c mycontainer ``` #### Connect Google Cloud Storage Backend Connect to Google Cloud Storage (not Google Drive). ``` # Connect GCS backend hoody files google-cloud-storage -c mycontainer ``` #### Connect Google Photos Backend Connect to Google Photos. ``` # Connect Google Photos backend hoody files google-photos -c mycontainer ``` #### Connect Hasher Backend Better checksums wrapper for other remotes. ``` # Connect hasher backend hoody files hasher -c mycontainer ``` #### Connect HDFS Backend Connect to Hadoop Distributed File System. ``` # Connect HDFS backend hoody files hdfs -c mycontainer ``` #### Connect HiDrive Backend Connect to HiDrive. ``` # Connect hidrive backend hoody files hidrive -c mycontainer ``` #### Connect HTTP Backend Connect to HTTP source. ``` # Connect HTTP backend hoody files http -c mycontainer ``` #### Connect iCloud Drive Backend Connect to iCloud Drive. ``` # Connect iCloud Drive backend hoody files iclouddrive -c mycontainer ``` #### Connect ImageKit Backend Connect to ImageKit. ``` # Connect ImageKit backend hoody files imagekit -c mycontainer ``` #### Connect Internet Archive Backend Connect to Internet Archive. ``` # Connect Internet Archive backend hoody files internetarchive -c mycontainer ``` #### Connect Jottacloud Backend Connect to Jottacloud. ``` # Connect Jottacloud backend hoody files jottacloud -c mycontainer ``` #### Connect Koofr Backend Connect to Koofr, Digi Storage, and Koofr-compatible providers. ``` # Connect Koofr backend hoody files koofr -c mycontainer ``` #### Connect Linkbox Backend Connect to Linkbox. ``` # Connect Linkbox backend hoody files linkbox -c mycontainer ``` #### Connect Local Backend Connect to local filesystem. ``` # Connect local backend hoody files local -c mycontainer ``` #### Connect Mail.ru Backend Connect to Mail.ru Cloud. ``` # Connect mailru backend hoody files mailru -c mycontainer ``` #### Connect Mega Backend Connect to Mega. ``` # Connect Mega backend hoody files mega -c mycontainer ``` #### Connect Memory Backend Connect to in-memory object storage. ``` # Connect memory backend hoody files memory -c mycontainer ``` #### Connect NetStorage Backend Connect to Akamai NetStorage. ``` # Connect NetStorage backend hoody files netstorage -c mycontainer ``` #### Connect OneDrive Backend Connect to Microsoft OneDrive. ``` # Connect OneDrive backend hoody files onedrive -c mycontainer ``` #### Connect OpenDrive Backend Connect to OpenDrive. ``` # Connect OpenDrive backend hoody files opendrive -c mycontainer ``` #### Connect Oracle Object Storage Backend Connect to Oracle Cloud Infrastructure Object Storage. ``` # Connect Oracle Object Storage backend hoody files oracleobjectstorage -c mycontainer ``` #### Connect pCloud Backend Connect to pCloud. ``` # Connect pCloud backend hoody files pcloud -c mycontainer ``` #### Connect PikPak Backend Connect to PikPak. ``` # Connect PikPak backend hoody files pikpak -c mycontainer ``` #### Connect Pixeldrain Backend Connect to Pixeldrain. ``` # Connect Pixeldrain backend hoody files pixeldrain -c mycontainer ``` #### Connect Premiumize.me Backend Connect to Premiumize.me. ``` # Connect premiumizeme backend hoody files premiumizeme -c mycontainer ``` #### Connect Proton Drive Backend Connect to Proton Drive. ``` # Connect Proton Drive backend hoody files protondrive -c mycontainer ``` #### Connect Put.io Backend Connect to Put.io. ``` # Connect Put.io backend hoody files putio -c mycontainer ``` #### Connect QingStor Backend Connect to QingStor. ``` # Connect QingStor backend hoody files qingstor -c mycontainer ``` #### Connect Quatrix Backend Connect to Quatrix. ``` # Connect Quatrix backend hoody files quatrix -c mycontainer ``` #### Connect S3 Backend Connect to Amazon S3 or S3-compatible storage (AWS, Alibaba, ArvanCloud, Ceph, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, MinIO, etc.). ``` # Connect S3 backend hoody files s3 -c mycontainer ``` #### Connect Seafile Backend Connect to Seafile. ``` # Connect Seafile backend hoody files seafile -c mycontainer ``` #### Connect SFTP Backend Connect via SFTP. ``` # Connect SFTP backend hoody files sftp -c mycontainer ``` #### Connect ShareFile Backend Connect to Citrix ShareFile. ``` # Connect ShareFile backend hoody files sharefile -c mycontainer ``` #### Connect Sia Backend Connect to Sia decentralized storage. ``` # Connect Sia backend hoody files sia -c mycontainer ``` #### Connect SMB Backend Connect to SMB/CIFS share. ``` # Connect SMB backend hoody files smb -c mycontainer ``` #### Connect Storj Backend Connect to Storj Decentralized Cloud Storage. ``` # Connect Storj backend hoody files storj -c mycontainer ``` #### Connect SugarSync Backend Connect to SugarSync. ``` # Connect SugarSync backend hoody files sugarsync -c mycontainer ``` #### Connect Swift Backend Connect to OpenStack Swift (Rackspace Cloud Files, Blomp, Memset, OVH). ``` # Connect Swift backend hoody files swift -c mycontainer ``` #### Connect Tardigrade Backend Connect to Tardigrade (Storj legacy). ``` # Connect Tardigrade backend hoody files tardigrade -c mycontainer ``` #### Connect Uloz.to Backend Connect to Uloz.to. ``` # Connect Uloz.to backend hoody files ulozto -c mycontainer ``` #### Connect Union Backend Union merges the contents of several upstream filesystems. ``` # Connect Union backend hoody files union -c mycontainer ``` #### Connect Uptobox Backend Connect to Uptobox. ``` # Connect Uptobox backend hoody files uptobox -c mycontainer ``` #### Connect WebDAV Backend Connect to WebDAV server (Nextcloud, ownCloud, etc.). ``` # Connect WebDAV backend hoody files webdav -c mycontainer ``` #### Connect Yandex Backend Connect to Yandex Disk. ``` # Connect Yandex backend hoody files yandex -c mycontainer ``` #### Connect Zoho Backend Connect to Zoho WorkDrive. ``` # Connect Zoho backend hoody files zoho -c mycontainer ``` --- ### Archive Operations #### Extract Archive Extract ZIP, TAR, or compressed TAR archives to a destination directory. Empty extraction extracts all; selective extraction matches specific entries. ``` # Extract full archive hoody files create /backups/archive.tar.gz -c mycontainer # JSON output hoody files create /backups/archive.tar.gz -c mycontainer -o json ``` #### Extract Single File from Archive Extract a single file or directory from inside an archive. Only the specified entry (and children if a directory) is extracted. ``` # Extract specific file from archive hoody files extract-file /backups/archive.zip -c mycontainer ``` #### Preview Archive Contents List contents of ZIP, TAR, or compressed TAR archives without extracting, or read a specific file from the archive. ``` # Preview archive listing hoody files preview /backups/archive.zip -c mycontainer # Read specific file from archive hoody files preview /backups/archive.zip -c mycontainer # JSON output hoody files preview /backups/archive.zip -c mycontainer -o json ``` #### View File from Archive Read and return a single file from inside an archive without extracting the entire archive. Returns raw file content with auto-detected MIME type. ``` # View file from archive hoody files view /backups/archive.tar.gz -c mycontainer ``` #### Download Directory as ZIP Create and download a directory as a ZIP archive. ``` # Download directory as ZIP hoody files zip /documents/reports -c mycontainer ``` --- ### Download Operations #### Download from URL Download a file from a remote URL to the server. ``` # Download file from URL hoody files url /downloads -c mycontainer ``` #### List Active Downloads Get progress of currently running downloads. ``` # List active downloads hoody files all -c mycontainer # Alternative using directory context hoody files active /downloads -c mycontainer ``` #### Download History Get history of past downloads. ``` # Get download history hoody files history -c mycontainer ``` --- ### Extraction Tracking #### List Active Extractions Get progress of currently running archive extractions. ``` # List active extractions hoody files active -c mycontainer ``` #### Extraction History Get history of past extractions (successful and failed). ``` # Get extraction history hoody files history -c mycontainer ``` --- ### Journal #### Query Journal Entries Query file mutation journal entries with optional filters. Supports cursor-based pagination. ``` # Query journal entries hoody files query -c mycontainer # JSON output hoody files query -c mycontainer -o json ``` #### Flush Journal Forces all pending journal entries to be written and fsynced to disk. Returns flushed status. ``` # Flush journal to disk hoody files flush -c mycontainer ``` #### Journal Statistics Returns storage statistics for the journal system including entry counts, blob storage usage, writer health, and pruning info. ``` # Get journal statistics hoody files stats -c mycontainer # JSON output hoody files stats -c mycontainer -o json ``` --- ### Mounts #### List Mounts Get list of all active filesystem mounts. All mounts are persistent and survive server restarts. ``` # List all mounts hoody files list -c mycontainer # JSON output hoody files list -c mycontainer -o json ``` #### Create Mount Create a persistent FUSE filesystem mount for a connected backend. All mounts are automatically persisted and restored on server restart. ``` # Create mount hoody files create -c mycontainer ``` #### Get Mount Details Get detailed information about a specific mount. ``` # Get mount by ID hoody files get -c mycontainer # JSON output hoody files get -c mycontainer -o json ``` #### Update Mount Update the VFS configuration for an existing mount. Allows changing cache settings, buffer sizes, and other VFS parameters. ``` # Update mount configuration hoody files update -c mycontainer ``` #### Unmount Remove a mount and disconnect the FUSE filesystem. ``` # Unmount filesystem hoody files unmount -c mycontainer ``` --- ### Remote File Access #### Access File via FTP Access files on an FTP server directly via URL pattern. ``` # Access file via FTP hoody files ftp /path/to/file -c mycontainer ``` #### Access File via Git Access files from GitHub, GitLab, Bitbucket, or custom Git servers. ``` # Fetch file from Git repository hoody files fetch-from-git /path/to/file -c mycontainer ``` #### Access File via S3 Access files from AWS S3 or S3-compatible storage. ``` # Access file from S3 hoody files s3 /path/to/file -c mycontainer ``` #### Access File via SSH/SFTP Connect to a remote SSH server and access files. ``` # Access file via SSH hoody files ssh /path/to/file -c mycontainer ``` #### Upload File via SSH/SFTP Upload a file to a remote SSH server. ``` # Upload file via SSH hoody files ssh-upload /path/to/file -c mycontainer ``` #### Access File via WebDAV Connect to a WebDAV server (Nextcloud, ownCloud, etc.). ``` # Access file via WebDAV hoody files webdav /path/to/file -c mycontainer ``` --- ### Image Processing #### Process and Convert Images On-the-fly image processing with format conversion, resizing, and effects. Supports JPEG, PNG, WebP, GIF, BMP. Works for both local files and all 60+ remote cloud storage backends. ``` # Process image hoody files process-image /images/photo.jpg -c mycontainer # JSON output hoody files process-image /images/photo.jpg -c mycontainer -o json ``` --- ## Advanced Operations ### Full Cloud Storage Setup Workflow This workflow demonstrates connecting to an S3-compatible backend, verifying the connection, listing files, uploading a file, then cleaning up. ``` # Step 1: Connect S3 backend hoody files s3 -c mycontainer # Step 2: Test the connection hoody files test -c mycontainer # Step 3: List all backends to confirm hoody files list -c mycontainer -o json # Step 4: List files in the backend hoody files get / -c mycontainer # Step 5: Upload a file hoody files put /data/export.csv -c mycontainer # Step 6: Verify upload with metadata hoody files stat /data/export.csv -c mycontainer # Step 7: Copy file to backup location hoody files copy /data/export.csv -c mycontainer # Step 8: Disconnect when done hoody files disconnect -c mycontainer ``` ### Archive Extraction and Processing Workflow Extract an archive, inspect contents, selectively extract files, then clean up. ``` # Step 1: Preview archive contents first hoody files preview /backups/project.tar.gz -c mycontainer -o json # Step 2: View a specific file without extracting hoody files view /backups/project.tar.gz -c mycontainer # Step 3: Extract full archive hoody files create /backups/project.tar.gz -c mycontainer # Step 4: Verify extraction hoody files get /backups/project -c mycontainer # Step 5: Check extraction history hoody files history -c mycontainer # Step 6: Track active extractions if large hoody files active -c mycontainer # Step 7: Delete source archive hoody files delete /backups/project.tar.gz --yes -c mycontainer ``` ### Batch File Operations Workflow Process multiple files using glob, grep, and batch operations. ``` # Step 1: Find all matching files hoody files glob /src/**/*.{ts,tsx} -c mycontainer -o json # Step 2: Search contents for a pattern hoody files grep /src -c mycontainer -o json # Step 3: Copy matching files to backup hoody files copy /src/components -c mycontainer # Step 4: Set permissions on copied files hoody files chmod /backup/components -c mycontainer # Step 5: Create ZIP of results hoody files zip /backup/components -c mycontainer # Step 6: Verify journal for mutations hoody files query -c mycontainer -o json ``` ### FUSE Mount Lifecycle Workflow Create a persistent mount for a cloud backend, use it, then clean up. ``` # Step 1: Connect the backend first hoody files s3 -c mycontainer # Step 2: Create FUSE mount hoody files create -c mycontainer # Step 3: List mounts to get ID hoody files list -c mycontainer -o json # Step 4: Get mount details hoody files get -c mycontainer # Step 5: Update mount VFS config if needed hoody files update -c mycontainer # Step 6: Use mounted filesystem hoody files get /mounted/data -c mycontainer # Step 7: Unmount when done hoody files unmount -c mycontainer # Step 8: Disconnect backend hoody files disconnect -c mycontainer ``` ### Journal Monitoring Workflow Monitor file mutations, query entries, flush to disk, and check statistics. ``` # Step 1: Query recent journal entries hoody files query -c mycontainer -o json # Step 2: Get journal statistics hoody files stats -c mycontainer -o json # Step 3: Flush pending entries to disk hoody files flush -c mycontainer # Step 4: Verify flush completed hoody files stats -c mycontainer -o json ``` ### Download and Archive Pipeline Download from URL, process, archive results. ``` # Step 1: Download file from remote URL hoody files url /downloads -c mycontainer # Step 2: Check download progress hoody files all -c mycontainer # Step 3: Verify downloaded file hoody files stat /downloads/data.csv -c mycontainer # Step 4: Download history hoody files history -c mycontainer # Step 5: Package directory as ZIP hoody files zip /downloads -c mycontainer ``` ### Image Processing Pipeline Download image, process with transformations, store result. ``` # Step 1: Access image from cloud backend hoody files s3 /images/original.jpg -c mycontainer # Step 2: Process image with conversions hoody files process-image /images/original.jpg -c mycontainer -o json # Step 3: Verify processed output hoody files stat /images/processed.jpg -c mycontainer # Step 4: Get thumbnail hoody files process-image /images/processed.jpg -c mycontainer ``` ### Multi-Backend Union Workflow Combine multiple cloud providers into a unified view. ``` # Step 1: Connect first backend (S3) hoody files s3 -c mycontainer # Step 2: Connect second backend (Dropbox) hoody files dropbox -c mycontainer # Step 3: Connect union backend combining both hoody files union -c mycontainer # Step 4: List all backends hoody files list -c mycontainer -o json # Step 5: Test each backend hoody files test -c mycontainer hoody files test -c mycontainer # Step 6: Access unified view hoody files get / -c mycontainer # Step 7: Copy files between backends via union hoody files copy /s3-data/file.txt -c mycontainer ``` ### Remote SSH File Transfer Workflow Connect to remote SSH server, transfer files, verify transfer. ``` # Step 1: Connect SFTP backend hoody files sftp -c mycontainer # Step 2: Test connection hoody files test -c mycontainer # Step 3: Access remote file hoody files ssh /remote/path/file.txt -c mycontainer # Step 4: Upload file to remote hoody files ssh-upload /local/file.txt -c mycontainer # Step 5: Verify on remote hoody files ssh /remote/path/file.txt -c mycontainer ``` ### Encrypted Storage Workflow Set up encrypted backend, store files securely. ``` # Step 1: Connect crypt backend wrapping an S3 backend hoody files crypt -c mycontainer # Step 2: Test the encrypted backend hoody files test -c mycontainer # Step 3: Upload sensitive file hoody files put /secure/data.csv -c mycontainer # Step 4: Verify file stored hoody files stat /secure/data.csv -c mycontainer # Step 5: List contents hoody files get /secure -c mycontainer # Step 6: Download and decrypt hoody files get /secure/data.csv -c mycontainer ``` ### Error Recovery Patterns #### Backend Connection Failure ``` # Step 1: Test backend connection hoody files test -c mycontainer # Step 2: If failed, update credentials hoody files update -c mycontainer # Step 3: Test again hoody files test -c mycontainer # Step 4: If still failing, disconnect and reconnect hoody files disconnect -c mycontainer hoody files s3 -c mycontainer # Step 5: Verify new connection hoody files test -c mycontainer ``` #### Interrupted Extraction ``` # Step 1: Check active extractions hoody files active -c mycontainer # Step 2: Check extraction history for failures hoody files history -c mycontainer # Step 3: Retry extraction hoody files create /backups/archive.tar.gz -c mycontainer # Step 4: Monitor progress hoody files active -c mycontainer ``` #### Incomplete Download Recovery ``` # Step 1: Check active downloads hoody files all -c mycontainer # Step 2: Check download history hoody files history -c mycontainer # Step 3: Re-download if needed hoody files url /downloads -c mycontainer # Step 4: Verify file integrity hoody files stat /downloads/file.dat -c mycontainer ``` --- ## Quick Reference ### Endpoint Groups Summary | Group | CLI Prefix | Description | Key Commands | |-------|-----------|-------------|--------------| | **File Operations** | `hoody files` | Core CRUD for files/dirs | `get`, `put`, `delete`, `copy`, `move` | | **File Metadata** | `hoody files` | Metadata and properties | `stat`, `metadata`, `options`, `realpath` | | **File Modification** | `hoody files` | Change properties | `chmod`, `chown`, `modify-properties`, `patch` | | **File Search** | `hoody files` | Search and query | `glob`, `grep`, `search` | | **File Utilities** | `hoody files` | Utility operations | `append`, `touch`, `health`, `version` | | **Backends** | `hoody files` | Cloud provider connections | `list`, `get`, `update`, `test`, `disconnect` | | **Backend Providers** | `hoody files` | 60+ provider connectors | `s3`, `azureblob`, `drive`, `dropbox`, etc. | | **Archives** | `hoody files` | Archive operations | `create`, `extract-file`, `preview`, `view`, `zip` | | **Downloads** | `hoody files` | Download management | `url`, `active`, `history` | | **Journal** | `hoody files` | Mutation journal | `query`, `flush`, `stats` | | **Mounts** | `hoody files` | FUSE mounts | `list`, `create`, `get`, `update`, `unmount` | | **Remote Access** | `hoody files` | Direct remote access | `ftp`, `fetch-from-git`, `s3`, `ssh`, `webdav` | | **Image Processing** | `hoody files` | Image transforms | `process-image` | ### Essential Parameters | Parameter | Usage | Example | |-----------|-------|---------| | `-c ` | Target container (required) | `-c mycontainer` | | `-o json` | Machine-readable output | `-o json` | | `--yes` | Skip confirmation prompts | `--yes` | | `-t ` | API token override | `-t eyJhbG...` | | `--profile` | Config profile | `--profile prod` | ### Backend Provider List (60+) All connect via `hoody files -c `: **Cloud Storage**: `s3`, `azureblob`, `azurefiles`, `b2`, `box`, `drive`, `dropbox`, `google-cloud-storage`, `google-photos`, `iclouddrive`, `koofr`, `mailru`, `mega`, `onedrive`, `opendrive`, `oracleobjectstorage`, `pcloud`, `pikpak`, `premiumizeme`, `protondrive`, `putio`, `qingstor`, `seafile`, `sharefile`, `storj`, `sugarsync`, `swift`, `tardigrade`, `yandex`, `zoho` **File Transfer**: `ftp`, `sftp`, `smb`, `webdav`, `http`, `ssh` **Specialized**: `alias`, `cache`, `chunker`, `cloudinary`, `combine`, `compress`, `crypt`, `filefabric`, `filescom`, `fichier`, `gofile`, `hasher`, `hdfs`, `hidrive`, `imagekit`, `internetarchive`, `jottacloud`, `linkbox`, `local`, `memory`, `netstorage`, `pixeldrain`, `quatrix`, `sia`, `ulozto`, `union`, `uptobox` ### Response Format All commands support output format control: ``` # Table (default) hoody files list -c mycontainer # JSON for machine processing hoody files list -c mycontainer -o json # YAML hoody files list -c mycontainer -o yaml # Wide table hoody files list -c mycontainer -o wide # Raw output hoody files list -c mycontainer -o raw # NDJSON (newline-delimited) hoody files list -c mycontainer -o ndjson # Pretty-printed JSON hoody files list -c mycontainer -o pretty ``` ### Common Workflow Patterns **Pattern: Connect and Use Backend** ``` Connect (provider) → Test (test) → Use (get/put) → Disconnect (disconnect) ``` **Pattern: Archive Processing** ``` Preview (preview) → Extract (create/view) → Process → Delete source ``` **Pattern: File Lifecycle** ``` Create (put/touch) → Modify (chmod/patch) → Copy/Move → Delete ``` **Pattern: Mount Lifecycle** ``` Connect backend → Create mount → Use mount → Update config → Unmount ``` **Pattern: Search and Process** ``` Find (glob) → Search (grep) → Copy → Archive (zip) ```