<!--
hoody-files Subskill (http)
Auto-generated by Hoody Skills Generator
Generated: 2026-06-20T00:51:49.254Z
Model: mimo-v2.5-pro
Mode: http


Tokens: 28911

DO NOT EDIT MANUALLY - Changes will be overwritten on next generation
-->

# hoody-files Subskill

## Overview

### What This Service Does

hoody-files provides universal file access across local storage and 60+ cloud storage providers through a unified API. Every file path is treated as a URL, enabling seamless operations across local filesystems, cloud storage, remote servers, and archive files with a single consistent interface.

**Core Capabilities:**
- **Unified File Operations** — Read, write, copy, move, delete files across any backend
- **60+ Cloud Provider Support** — AWS S3, Google Cloud Storage, Azure Blob/Files, Dropbox, Box, OneDrive, and many more
- **Archive Management** — Extract, preview, and manipulate ZIP, TAR, and compressed archives
- **Image Processing** — On-the-fly resizing, format conversion, and thumbnail generation
- **Remote Access** — Direct access to FTP, SFTP/SSH, Git repositories, and WebDAV servers
- **File Search** — Glob pattern matching and regex content search across all backends
- **Journal System** — Track all file mutations with queryable audit trail
- **FUSE Mounts** — Create persistent filesystem mounts for remote backends
- **Download Management** — Background download operations with progress tracking

### When to Use This Service

Use hoody-files when your application needs to:

1. **Store and retrieve files** across heterogeneous storage backends
2. **Manage cloud storage** connections without provider-specific SDKs
3. **Process archives** — extract, compress, or inspect archive contents
4. **Transform images** — resize, convert formats, generate thumbnails
5. **Access remote servers** — SSH, FTP, Git, WebDAV without separate clients
6. **Search file contents** across local and remote storage
7. **Track file changes** with mutation journaling
8. **Mount remote storage** as local filesystems via FUSE

### Authentication Model

hoody-files runs as a Hoody Kit service within a container. Access is provided through:

- **Container Service URLs** — The service is accessed via its Hoody Kit container URL (see Base URL section)
- **Backend Credentials** — Cloud provider credentials are stored securely in the service and referenced by backend ID
- **Remote Auth** — SSH keys, FTP passwords, and OAuth tokens are managed per-backend

No separate authentication headers are required when accessing the service from within the same Hoody project container network. External access uses Hoody Proxy authentication.

### How It Fits Into Hoody Philosophy

hoody-files embodies the Hoody philosophy of **universal, provider-agnostic infrastructure**. Rather than building application logic around specific cloud SDKs, you interact with a single file API that abstracts away provider differences. This enables:

- **Zero vendor lock-in** — Switch between providers without code changes
- **Consistent file semantics** — Same operations work locally and on any cloud
- **Path-as-URL model** — Intuitive addressing where every file has a deterministic path
- **Composable backends** — Combine, encrypt, cache, or chunk any backend transparently

---

## Core Resource Workflows

### 1. Backend Management (Cloud Provider Connections)

Backends represent connections to storage providers. Each backend has a unique ID and can be referenced in file operations.

#### List All Connected Backends

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends"
```

**Response format:**
```
[
  {
    "id": "my-s3",
    "type": "s3",
    "name": "My S3 Bucket",
    "status": "connected"
  }
]
```

#### Get Backend Details

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}"
```

#### Test Backend Connection

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}/test"
```

**Response format:**
```
{
  "success": true,
  "message": "Connection test passed"
}
```

#### Update Backend Credentials

Rotate credentials for an existing backend. Identity fields (host, user, port, type) cannot be changed — disconnect and reconnect for those changes.

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "new-access-key"
  }'
```

#### Delete Backend

```
curl -s -X DELETE \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}"
```

---

### 2. Creating Cloud Provider Backends

Each cloud provider has its own endpoint with specific required fields.

#### Amazon S3 and S3-Compatible Storage

Supports AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, and more.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-s3-bucket",
    "provider": "AWS",
    "access_key_id": "AKIAIOSFODNN7EXAMPLE",
    "secret_access_key": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "region": "us-east-1",
    "bucket": "my-bucket"
  }'
```

#### Google Cloud Storage

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/google-cloud-storage" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-gcs",
    "project_number": "123456789",
    "bucket": "my-gcs-bucket",
    "service_account_credentials": "{\"type\": \"service_account\", ...}"
  }'
```

#### Azure Blob Storage

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/azureblob" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-azure-blob",
    "account": "myaccount",
    "key": "storage-account-key",
    "container": "my-container"
  }'
```

#### Azure Files

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/azurefiles" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-azure-files",
    "account": "myaccount",
    "key": "storage-account-key",
    "share": "my-share"
  }'
```

#### Backblaze B2

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/b2" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-b2",
    "account": "B2_ACCOUNT_ID",
    "key": "B2_APPLICATION_KEY",
    "bucket": "my-b2-bucket"
  }'
```

#### Box

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/box" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-box",
    "client_id": "box-client-id",
    "client_secret": "box-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Dropbox

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/dropbox" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-dropbox",
    "client_id": "dropbox-client-id",
    "client_secret": "dropbox-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Google Drive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/drive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-gdrive",
    "client_id": "google-client-id",
    "client_secret": "google-client-secret",
    "scope": "drive",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### OneDrive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/onedrive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-onedrive",
    "client_id": "microsoft-client-id",
    "client_secret": "microsoft-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### FTP Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/ftp" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-ftp",
    "host": "ftp.example.com",
    "user": "ftpuser",
    "pass": "ftppassword",
    "port": 21
  }'
```

#### SFTP Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/sftp" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-sftp",
    "host": "sftp.example.com",
    "user": "sftpuser",
    "pass": "sftppassword",
    "port": 22
  }'
```

#### SMB/CIFS Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/smb" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-smb",
    "host": "smb.example.com",
    "user": "smbuser",
    "pass": "smbpassword",
    "domain": "WORKGROUP"
  }'
```

#### WebDAV Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/webdav" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-webdav",
    "url": "https://cloud.example.com/dav",
    "user": "webdavuser",
    "pass": "webdavpassword"
  }'
```

#### Storj Decentralized Storage

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/storj" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-storj",
    "api_key": "storj-api-key",
    "passphrase": "storj-passphrase",
    "satellite_address": "us1.storj.io",
    "bucket": "my-storj-bucket"
  }'
```

#### OpenStack Swift

Supports Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/swift" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-swift",
    "user": "swiftuser",
    "key": "swiftkey",
    "auth": "https://auth.cloud.example.com/v3",
    "tenant": "my-tenant",
    "container": "my-container"
  }'
```

#### Koofr

Supports Koofr, Digi Storage and other Koofr-compatible storage providers.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/koofr" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-koofr",
    "user": "koofr@example.com",
    "password": "koofr-password"
  }'
```

#### Oracle Object Storage

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/oracleobjectstorage" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-oracle-oss",
    "namespace": "my-namespace",
    "compartment": "ocid1.compartment.oc1..example",
    "region": "us-ashburn-1",
    "bucket": "my-bucket",
    "user": "ocid1.user.oc1..example",
    "key_file": "/path/to/key.pem",
    "fingerprint": "aa:bb:cc:dd:ee:ff:00:11:22:33:44:55:66:77:88:99"
  }'
```

#### Cloudinary

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/cloudinary" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-cloudinary",
    "cloud_name": "my-cloud-name",
    "api_key": "123456789012345",
    "api_secret": "my-api-secret"
  }'
```

#### Mega

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/mega" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-mega",
    "user": "mega@example.com",
    "password": "mega-password"
  }'
```

#### pCloud

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/pcloud" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-pcloud",
    "client_id": "pcloud-client-id",
    "client_secret": "pcloud-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### ProtonDrive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/protondrive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-protondrive",
    "username": "user@protonmail.com",
    "password": "proton-password"
  }'
```

#### Yandex Disk

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/yandex" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-yandex",
    "client_id": "yandex-client-id",
    "client_secret": "yandex-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Put.io

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/putio" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-putio",
    "client_id": "putio-client-id",
    "client_secret": "putio-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### HiDrive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/hidrive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-hidrive",
    "client_id": "hidrive-client-id",
    "client_secret": "hidrive-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Internet Archive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/internetarchive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-internetarchive",
    "access_key_id": "IA_ACCESS_KEY",
    "secret_access_key": "IA_SECRET_KEY"
  }'
```

#### Seafile

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/seafile" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-seafile",
    "url": "https://cloud.example.com",
    "user": "seafile@example.com",
    "password": "seafile-password",
    "library": "my-library-id"
  }'
```

#### ShareFile

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/sharefile" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-sharefile",
    "client_id": "sharefile-client-id",
    "client_secret": "sharefile-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Jottacloud

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/jottacloud" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-jottacloud",
    "user": "jotta@example.com",
    "password": "jotta-password"
  }'
```

#### PikPak

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/pikpak" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-pikpak",
    "user": "pikpak@example.com",
    "password": "pikpak-password"
  }'
```

#### IONOS

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/ilionx" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-ionos",
    "access_key_id": "IONOS_ACCESS_KEY",
    "secret_access_key": "IONOS_SECRET_KEY",
    "bucket": "my-ionos-bucket"
  }'
```

#### Google Photos

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/google-photos" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-google-photos",
    "client_id": "google-client-id",
    "client_secret": "google-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### iCloud Drive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/iclouddrive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-icloud",
    "apple_id": "user@icloud.com",
    "password": "icloud-password"
  }'
```

#### SugarSync

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/sugarsync" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-sugarsync",
    "access_key_id": "SS_ACCESS_KEY",
    "private_access_key": "SS_PRIVATE_KEY"
  }'
```

#### Mail.ru Cloud

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/mailru" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-mailru",
    "user": "user@mail.ru",
    "password": "mailru-password"
  }'
```

#### OpenDrive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/opendrive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-opendrive",
    "user": "opendrive@example.com",
    "password": "opendrive-password"
  }'
```

#### Quatrix

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/quatrix" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-quatrix",
    "api_token": "quatrix-api-token"
  }'
```

#### Sia Decentralized Storage

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/sia" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-sia",
    "api_password": "sia-api-password",
    "url": "http://localhost:9980"
  }'
```

#### QingStor

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/qingstor" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-qingstor",
    "access_key_id": "QING_ACCESS_KEY",
    "secret_access_key": "QING_SECRET_KEY",
    "bucket": "my-qingstor-bucket",
    "zone": "pek3b"
  }'
```

#### HDFS

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/hdfs" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-hdfs",
    "namenode": "namenode.example.com",
    "port": 8020,
    "user": "hdfs-user"
  }'
```

#### NetStorage (Akamai)

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/netstorage" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-netstorage",
    "host": "example-nsu.akamaihd.net",
    "account": "akamai-account",
    "key": "akamai-key"
  }'
```

#### Gofile

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/gofile" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-gofile",
    "api_key": "gofile-api-key"
  }'
```

#### Pixeldrain

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/pixeldrain" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-pixeldrain",
    "api_key": "pixeldrain-api-key"
  }'
```

#### Premiumize.me

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/premiumizeme" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-premiumize",
    "api_key": "premiumize-api-key"
  }'
```

#### Files.com

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/filescom" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-filescom",
    "api_key": "filescom-api-key"
  }'
```

#### Fichier

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/fichier" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-fichier",
    "api_key": "fichier-api-key"
  }'
```

#### Uptobox

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/uptobox" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-uptobox",
    "api_key": "uptobox-api-key"
  }'
```

#### Uloz.to

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/ulozto" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-ulozto",
    "user": "ulozto@example.com",
    "password": "ulozto-password"
  }'
```

#### Linkbox

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/linkbox" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-linkbox",
    "api_key": "linkbox-api-key"
  }'
```

#### HTTP Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/http" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-http",
    "url": "https://files.example.com"
  }'
```

#### ImageKit

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/imagekit" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-imagekit",
    "public_key": "imagekit-public-key",
    "private_key": "imagekit-private-key",
    "url_endpoint": "https://ik.imagekit.io/my-id"
  }'
```

#### FileFabric

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/filefabric" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-filefabric",
    "url": "https://fabric.example.com",
    "user": "filefabric@example.com",
    "password": "filefabric-password"
  }'
```

#### Zoho WorkDrive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/zoho" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-zoho",
    "client_id": "zoho-client-id",
    "client_secret": "zoho-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

---

### 3. Virtual Backend Utilities

These backends provide transparent transformations and combinations of other backends.

#### Alias Backend

Creates an alias (shortcut) to a path within another remote.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/alias" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-alias",
    "remote": "my-s3:bucket/path/to/dir"
  }'
```

#### Cache Backend

Adds a caching layer around any remote backend for faster repeated access.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/cache" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cached-s3",
    "remote": "my-s3:bucket/path"
  }'
```

#### Chunker Backend

Transparently chunk/split large files for backends with file size limits.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/chunker" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "chunked-s3",
    "remote": "my-s3:bucket/path"
  }'
```

#### Crypt Backend

Encrypts/decrypts files transparently on any backend.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/crypt" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "encrypted-s3",
    "remote": "my-s3:bucket/path",
    "password": "encryption-password"
  }'
```

#### Compress Backend

Transparently compresses files on any backend.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/compress" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "compressed-s3",
    "remote": "my-s3:bucket/path"
  }'
```

#### Hasher Backend

Better checksums for other remotes.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/hasher" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "hashed-s3",
    "remote": "my-s3:bucket/path"
  }'
```

#### Combine Backend

Merges the contents of several upstream filesystems into one virtual filesystem.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/combine" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "combined",
    "upstreams": "my-s3:bucket1 my-gcs:bucket2 my-dropbox:"
  }'
```

#### Union Backend

Union merges the contents of several upstream filesystems.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/union" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-union",
    "upstreams": "my-s3:bucket my-dropbox:"
  }'
```

#### Memory Backend

In-memory object storage system — useful for testing and temporary storage.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/memory" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-memory"
  }'
```

#### Local Backend

Mount a local directory as a managed backend.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/local" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-local",
    "root": "/data/files"
  }'
```

---

### 4. File Operations (Root-Level API)

Root-level file paths provide direct access to files and directories.

#### List Directory or Download File

```
# List directory contents (returns HTML by default)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}"

# List directory contents as JSON
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?json"

# Download a file (force attachment)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{file-path}?download" \
  -o local-file.txt
```

#### Upload File

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @local-file.txt
```

#### Modify File Properties

Supports resumable upload, append to files, change permissions (Unix only), change ownership (Unix only), rename file or directory.

```
# Rename a file
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "new-name.txt"
  }'

# Move to different directory
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "move_to": "/new/directory/"
  }'
```

#### Delete File or Directory

```
curl -s -X DELETE \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}"
```

#### Get File Metadata (HEAD)

```
curl -s -I \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}"
```

#### WebDAV Capabilities (OPTIONS)

Returns supported HTTP methods and WebDAV capabilities.

```
curl -s -X OPTIONS \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}"
```

#### Create or Touch File

Create an empty file if it does not exist, or update the modification time if it does.

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?touch"
```

#### Search Files

```
# Search for files matching query (HTML response)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?q=searchterm"

# Search for files matching query (JSON response)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?q=searchterm&json"
```

---

### 5. File Operations (API v1)

The API v1 endpoints provide more advanced file operations with consistent JSON responses.

#### List Directory (JSON)

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}"
```

**Response format:**
```
[
  {
    "name": "file.txt",
    "path": "/dir/file.txt",
    "size": 1234,
    "modified": "2025-01-15T10:30:00Z",
    "is_dir": false
  }
]
```

#### Download File

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -o local-file.txt
```

#### Upload File

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @local-file.txt
```

#### Append to File

Append binary data to end of an existing file. Creates the file if it does not exist. Auto-creates parent directories.

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/append/{path}" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @data-to-append.txt
```

#### Create Directory

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "create_dir": true
  }'
```

#### Extract Archive

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "extract": true,
    "destination": "/extracted/"
  }'
```

#### Download from URL

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "download_url": "https://example.com/file.zip"
  }'
```

#### Copy File

Copy a file or directory to a new location. Supports recursive directory copy. Auto-creates parent directories at destination. Use `?overwrite=true` to replace existing destination.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/copy/{source-path}" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "/new/path/"
  }'

# With overwrite
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/copy/{source-path}?overwrite=true" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "/new/path/"
  }'
```

#### Move File

Move or rename a file/directory to a new location. Works across directories. Auto-creates parent directories at destination. Requires both upload and delete permissions.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/move/{source-path}" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "/new/path/"
  }'
```

#### Change Permissions (Unix Only)

Change file or directory permissions using octal mode. Pass the mode value in the chmod query parameter.

```
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/chmod/{path}?chmod=755"
```

#### Change Ownership (Unix Only)

Change file or directory ownership. Pass owner:group in the chown query parameter. Group is optional.

```
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/chown/{path}?chown=user:group"
```

#### Get File Stats

Get detailed metadata (stat) for a single file or directory without downloading content.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/stat/{path}"
```

**Response format:**
```
{
  "name": "file.txt",
  "path": "/dir/file.txt",
  "size": 1234,
  "modified": "2025-01-15T10:30:00Z",
  "is_dir": false,
  "permissions": "0644",
  "owner": "user",
  "group": "group",
  "mime_type": "text/plain"
}
```

#### Resolve Real Path

Resolve a file or directory path to its canonical absolute form by following all symbolic links and resolving all `.`/`..` segments.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/realpath/{path}"
```

**Response format:**
```
{
  "path": "/absolute/path/to/file.txt"
}
```

#### 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 Python files recursively
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/glob/{directory}/**/*.py"
```

**Response format:**
```
[
  {
    "name": "main.py",
    "path": "/dir/src/main.py",
    "size": 5678,
    "modified": "2025-01-15T10:30:00Z",
    "is_dir": false
  }
]
```

#### Grep Search

Search file or directory contents using regex patterns. Powered by ripgrep engine with .gitignore support, binary file detection, and configurable limits.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/grep/{path}?pattern=searchterm"

# With context lines
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/grep/{path}?pattern=searchterm&context=2"
```

**Response format:**
```
[
  {
    "path": "/dir/file.txt",
    "line_number": 42,
    "line": "This line contains searchterm in it.",
    "context_before": ["line 41", "line 40"],
    "context_after": ["line 43", "line 44"]
  }
]
```

#### Modify File (PATCH via API v1)

Modify file properties via REST API v1. Supports chmod, chown, rename, and cross-directory move.

```
# Rename via JSON body
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "new-name.txt"
  }'

# Move via JSON body
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}" \
  -H "Content-Type: application/json" \
  -d '{
    "move_to": "/new/directory/"
  }'

# Change permissions
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}?chmod=644"

# Change ownership
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}?chown=user:group"
```

#### Delete File (API v1)

```
curl -s -X DELETE \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}"
```

#### Upload to Remote Backend

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/{path}?backend=my-s3" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @local-file.txt
```

#### File Health Check

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/health"
```

**Response format:**
```
{
  "status": "healthy",
  "version": "1.0.0",
  "uptime": 86400,
  "timestamp": "2025-01-15T10:30:00Z"
}
```

---

### 6. Archive Operations

#### Preview Archive Contents

List contents of ZIP, TAR, or compressed TAR archives without extracting.

```
# List all entries
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?preview"

# Read a specific file from archive
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?preview=path/inside/archive.txt"
```

**Response format (listing):**
```
[
  {
    "name": "file.txt",
    "path": "dir/file.txt",
    "size": 1234,
    "modified": "2025-01-15T10:30:00Z",
    "is_dir": false
  }
]
```

#### View File from Archive

Read and return a single file from inside a ZIP, TAR, or compressed TAR archive without extracting the entire archive. Returns the raw file content with auto-detected MIME type.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?view_file=path/inside/archive.txt" \
  -o extracted-file.txt
```

#### Extract Entire Archive

Extract ZIP, TAR, or compressed TAR archives to destination directory. Empty `?extract` extracts all; `?extract=<path>` selectively extracts matching entries.

```
# Extract all files
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?extract"

# Extract to specific destination
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?extract&destination=/extracted/"

# Extract specific path pattern
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?extract=*.txt"
```

#### Extract Single File from Archive

Extract a single file or directory from inside a ZIP, TAR, or compressed TAR archive to a destination directory. Only the specified entry (and its children if a directory) is extracted.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{archive}?extract_file=path/inside/archive.txt&destination=/extracted/"
```

#### Create ZIP Archive from Directory

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?zip" \
  -o archive.zip
```

#### View Extraction History

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/?extraction_history"
```

#### View Active Extractions

```
# Root-level endpoint
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/?extractions"

# API v1 endpoint
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/extractions"
```

---

### 7. Download Operations

#### Download File from Remote URL

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?download=https://example.com/file.zip"
```

#### View Download Progress

```
# Root-level endpoint
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{directory}?downloads"

# API v1 endpoint
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/downloads"
```

#### View Download History

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/?download_history"
```

---

### 8. Image Processing

On-the-fly image processing with format conversion, resizing, and effects. Supports JPEG, PNG, WebP, GIF, BMP input/output. Works for both local files and all 60+ remote cloud storage backends.

#### Generate Thumbnail

```
# Basic thumbnail
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{image}?thumbnail" \
  -o thumbnail.jpg

# With resize parameters
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{image}?thumbnail&width=200&height=200" \
  -o thumbnail.jpg

# Format conversion
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{image}?thumbnail&format=webp" \
  -o thumbnail.webp
```

---

### 9. Remote Access Protocols

#### Access Files via Git

Access files from GitHub, GitLab, Bitbucket, or custom Git servers.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=git&repo=https://github.com/user/repo.git&ref=main"
```

#### Access Files via S3

Access AWS S3 or S3-compatible storage (MinIO, DigitalOcean Spaces, etc.).

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=s3&bucket=my-bucket&region=us-east-1"
```

#### Access Files via SSH

Connect to remote SSH server and access files.

```
# Read file
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=ssh&host=ssh.example.com&user=sshuser"

# Upload file
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=ssh&host=ssh.example.com&user=sshuser" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @local-file.txt
```

#### Access Files via FTP

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=ftp&host=ftp.example.com&user=ftpuser"
```

#### Access Files via WebDAV

Connect to WebDAV server (Nextcloud, ownCloud, etc.).

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/{path}?type=webdav&host=cloud.example.com&user=webdavuser"
```

---

### 10. FUSE Mounts

Create persistent FUSE filesystem mounts for connected backends, allowing direct file system access to remote storage. All mounts are automatically persisted and restored on server restart.

#### List All Mounts

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts"

# Filter by label
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts?label=production"
```

**Response format:**
```
[
  {
    "id": "mount-abc123",
    "backend_id": "my-s3",
    "mount_point": "/mnt/my-s3",
    "status": "mounted",
    "labels": {
      "environment": "production"
    }
  }
]
```

#### Create Mount

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts" \
  -H "Content-Type: application/json" \
  -d '{
    "backend_id": "my-s3",
    "mount_point": "/mnt/my-s3",
    "labels": {
      "environment": "production"
    },
    "vfs_config": {
      "cache_max_age": 300,
      "buffer_size": 10485760
    }
  }'
```

#### Get Mount Details

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts/{id}"
```

#### Update Mount Configuration

Update the VFS configuration for an existing mount. Allows changing cache settings, buffer sizes, and other VFS parameters.

```
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts/{id}" \
  -H "Content-Type: application/json" \
  -d '{
    "vfs_config": {
      "cache_max_age": 600,
      "buffer_size": 20971520
    }
  }'
```

#### Remove Mount

Remove a mount and disconnect the FUSE filesystem.

```
curl -s -X DELETE \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts/{id}"
```

---

### 11. Journal System

The journal tracks all file mutations with a queryable audit trail.

#### Query Journal Entries

Query file mutation journal entries with optional filters. Supports cursor-based pagination via `after_id`.

```
# Query all entries
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal"

# Query with filters
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal?operation=write&path=/dir/"

# Paginate with cursor
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal?after_id=entry-123&limit=50"
```

**Response format:**
```
[
  {
    "id": "entry-123",
    "timestamp": "2025-01-15T10:30:00Z",
    "operation": "write",
    "path": "/dir/file.txt",
    "size": 1234,
    "backend": "my-s3"
  }
]
```

#### Get Journal Statistics

Returns storage statistics for the journal system including entry counts, blob storage usage, writer health, and pruning info.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal/stats"
```

**Response format:**
```
{
  "entry_count": 15000,
  "blob_storage_bytes": 1048576,
  "writer_healthy": true,
  "pruning": {
    "enabled": true,
    "max_age_days": 30,
    "last_pruned": "2025-01-14T00:00:00Z"
  }
}
```

#### Flush Journal

Forces all pending journal entries to be written and fsynced to disk. Returns 200 with `flushed=true` if all entries were durably persisted, or 503 with `flushed=false` if flush failed or entries were lost.

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal/flush"
```

**Response format (success):**
```
{
  "flushed": true
}
```

**Response format (failure):**
```
{
  "flushed": false,
  "error": "Disk write failed"
}
```

---

### 12. System Information

#### Get Version

Returns the current API version and server information.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/version"
```

**Response format:**
```
{
  "version": "1.0.0",
  "build": "2025-01-15T10:00:00Z",
  "started": "2025-01-15T10:05:00Z"
}
```

#### Health Check

Standard service health endpoint. Returns service identity, build and start timestamps, resource usage, and caller metadata.

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/health"
```

**Response format:**
```
{
  "status": "healthy",
  "service": "hoody-files",
  "version": "1.0.0",
  "build_timestamp": "2025-01-15T10:00:00Z",
  "start_timestamp": "2025-01-15T10:05:00Z",
  "uptime_seconds": 86400,
  "memory_usage_mb": 256,
  "cpu_usage_percent": 15.5,
  "caller": {
    "ip": "192.168.1.100",
    "user_agent": "curl/8.0"
  }
}
```

---

## Advanced Operations

### 1. Full Backend-to-File Workflow

Complete workflow: connect a cloud backend, upload files, search, and manage.

#### Step 1: Connect Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "production-s3",
    "provider": "AWS",
    "access_key_id": "AKIAIOSFODNN7EXAMPLE",
    "secret_access_key": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "region": "us-east-1",
    "bucket": "production-files"
  }'
```

#### Step 2: Verify Connection

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/production-s3/test"
```

#### Step 3: Upload Files

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/documents/report.pdf?backend=production-s3" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @report.pdf
```

#### Step 4: List Uploaded Files

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/documents/?backend=production-s3"
```

#### Step 5: Search Content

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/grep/documents/?backend=production-s3&pattern=revenue"
```

#### Step 6: Check Journal for Changes

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal?backend=production-s3"
```

---

### 2. Encrypted Backup Pipeline

Create an encrypted, cached copy of files from one backend to another.

#### Step 1: Connect Source Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/drive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "source-gdrive",
    "client_id": "google-client-id",
    "client_secret": "google-client-secret",
    "scope": "drive",
    "token": "{\"access_token\": \"ya29...\", \"refresh_token\": \"1//0g...\"}"
  }'
```

#### Step 2: Connect Destination with Encryption and Caching

```
# Create the raw S3 backend
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "backup-s3-raw",
    "provider": "AWS",
    "access_key_id": "AKIAIOSFODNN7EXAMPLE",
    "secret_access_key": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "region": "us-east-1",
    "bucket": "backup-bucket"
  }'

# Create encrypted wrapper
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/crypt" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "backup-encrypted",
    "remote": "backup-s3-raw:",
    "password": "strong-encryption-password"
  }'

# Create cached layer for faster access
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/cache" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "backup-cached",
    "remote": "backup-encrypted:"
  }'
```

#### Step 3: Copy Files Between Backends

```
# Copy from Google Drive to encrypted backup
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/copy/documents/?backend=source-gdrive" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "/backups/daily/",
    "destination_backend": "backup-cached"
  }'
```

#### Step 4: Verify Backup Integrity

```
# List backed-up files
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/backups/daily/?backend=backup-cached"

# Check stats of specific file
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/stat/backups/daily/report.pdf?backend=backup-cached"
```

---

### 3. Archive Processing Pipeline

Full workflow for downloading, extracting, processing, and re-archiving files.

#### Step 1: Download Archive from URL

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/?download=https://example.com/data-export.zip"
```

#### Step 2: Preview Archive Contents

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/data-export.zip?preview"
```

#### Step 3: Extract Specific Files

```
# Extract only CSV files
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/data-export.zip?extract=*.csv"
```

#### Step 4: Search Extracted Content

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/grep/?pattern=error&context=2"
```

#### Step 5: Repackage Processed Files

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/processed/?zip" \
  -o processed-data.zip
```

---

### 4. Multi-Backend Union with Mounts

Create a unified view of multiple storage backends via FUSE mounts.

#### Step 1: Connect Multiple Backends

```
# Connect S3
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "s3-assets",
    "provider": "AWS",
    "access_key_id": "AKIAIOSFODNN7EXAMPLE",
    "secret_access_key": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "region": "us-east-1",
    "bucket": "assets-bucket"
  }'

# Connect Dropbox
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/dropbox" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "dropbox-personal",
    "client_id": "dropbox-client-id",
    "client_secret": "dropbox-client-secret",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'

# Connect Google Drive
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/drive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "gdrive-work",
    "client_id": "google-client-id",
    "client_secret": "google-client-secret",
    "scope": "drive",
    "token": "{\"access_token\": \"...\", \"refresh_token\": \"...\"}"
  }'
```

#### Step 2: Create Union Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/union" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "unified-storage",
    "upstreams": "s3-assets: dropbox-personal: gdrive-work:"
  }'
```

#### Step 3: Create FUSE Mount

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts" \
  -H "Content-Type: application/json" \
  -d '{
    "backend_id": "unified-storage",
    "mount_point": "/mnt/unified",
    "labels": {
      "environment": "production",
      "team": "engineering"
    }
  }'
```

#### Step 4: Verify Mount and List Files

```
# Check mount status
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts"

# List files across all backends
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/?backend=unified-storage"
```

---

### 5. SSH File Transfer Workflow

#### Step 1: Connect SFTP Backend

```
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/sftp" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "production-server",
    "host": "server.example.com",
    "user": "deploy",
    "key_file": "/root/.ssh/id_rsa",
    "port": 22
  }'
```

#### Step 2: Upload Deployment Files

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/app/deploy.sh?backend=production-server" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @deploy.sh
```

#### Step 3: Set Permissions

```
curl -s -X PATCH \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/chmod/app/deploy.sh?chmod=755&backend=production-server"
```

#### Step 4: Verify Deployment

```
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/stat/app/deploy.sh?backend=production-server"
```

---

### 6. Image Processing Pipeline

#### Step 1: Upload Original Image

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/images/original/photo.png" \
  -H "Content-Type: image/png" \
  --data-binary @photo.png
```

#### Step 2: Generate Multiple Thumbnail Sizes

```
# Small thumbnail (100x100)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/images/original/photo.png?thumbnail&width=100&height=100" \
  -o photo-thumb-100.jpg

# Medium thumbnail (300x300)
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/images/original/photo.png?thumbnail&width=300&height=300" \
  -o photo-thumb-300.jpg

# WebP format for web
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/images/original/photo.png?thumbnail&width=800&format=webp" \
  -o photo-web.webp
```

#### Step 3: Upload Processed Images

```
curl -s -X PUT \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/images/processed/photo-thumb-100.jpg" \
  -H "Content-Type: image/jpeg" \
  --data-binary @photo-thumb-100.jpg
```

---

### 7. Bulk File Operations

#### Batch Copy Multiple Files

```
# Copy files matching glob pattern
for file in $(curl -s "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/glob/source/?*.txt" | jq -r '.[].path'); do
  curl -s -X POST \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/copy${file}" \
    -H "Content-Type: application/json" \
    -d '{"destination": "/destination/"}'
done
```

#### Batch Delete Temporary Files

```
# Find and delete old temp files
for file in $(curl -s "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/glob/?tmp_*" | jq -r '.[].path'); do
  curl -s -X DELETE \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files${file}"
done
```

---

### 8. Error Recovery Patterns

#### Backend Connection Failure

```
# Test connection
response=$(curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}/test")

success=$(echo "$response" | jq -r '.success')
if [ "$success" != "true" ]; then
  # Rotate credentials
  curl -s -X PUT \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}" \
    -H "Content-Type: application/json" \
    -d '{"key": "new-access-key"}'
  
  # Test again
  curl -s \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/{id}/test"
fi
```

#### Journal Flush After Critical Operation

```
# After critical file operation, ensure journal is flushed
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal/flush"
```

#### Mount Recovery

```
# Check mount status
mounts=$(curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts")

# If mount is unhealthy, delete and recreate
unhealthy=$(echo "$mounts" | jq -r '.[] | select(.status != "mounted") | .id')
for mount_id in $unhealthy; do
  # Delete unhealthy mount
  curl -s -X DELETE \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts/$mount_id"
  
  # Recreate mount (get config from details first)
  curl -s -X POST \
    "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/mounts" \
    -H "Content-Type: application/json" \
    -d '{
      "backend_id": "my-backend",
      "mount_point": "/mnt/my-backend"
    }'
done
```

---

### 9. Multi-Resource Orchestration

#### Complete Storage Migration

```
# Step 1: Connect source (old storage)
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "old-storage",
    "provider": "AWS",
    "access_key_id": "OLD_ACCESS_KEY",
    "secret_access_key": "OLD_SECRET_KEY",
    "region": "us-west-2",
    "bucket": "old-bucket"
  }'

# Step 2: Connect destination (new storage)
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/s3" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "new-storage",
    "provider": "AWS",
    "access_key_id": "NEW_ACCESS_KEY",
    "secret_access_key": "NEW_SECRET_KEY",
    "region": "us-east-1",
    "bucket": "new-bucket"
  }'

# Step 3: Verify both connections
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/old-storage/test"

curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/new-storage/test"

# Step 4: List all files in source
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/?backend=old-storage"

# Step 5: Copy all files to destination
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/copy/?backend=old-storage" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "/",
    "destination_backend": "new-storage"
  }'

# Step 6: Verify migration
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/files/?backend=new-storage"

# Step 7: Check journal for complete audit trail
curl -s \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal?backend=new-storage"

# Step 8: Flush journal to ensure all operations are recorded
curl -s -X POST \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/journal/flush"

# Step 9: Remove old backend
curl -s -X DELETE \
  "https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com/api/v1/backends/old-storage"
```

---

## Quick Reference

### All Endpoint Groups

| Group | Method | Path | Description |
|-------|--------|------|-------------|
| **Root Files** | GET | `/{path}` | List directory or download file |
| | PUT | `/{path}` | Upload file |
| | PATCH | `/{path}` | Modify file properties |
| | DELETE | `/{path}` | Delete file or directory |
| | HEAD | `/{path}` | Get file metadata |
| | OPTIONS | `/{path}` | WebDAV capabilities |
| | PUT | `/{path}?touch` | Create or touch file |
| **Root Queries** | GET | `/?download_history` | Download history |
| | GET | `/?extraction_history` | Extraction history |
| | GET | `/?extractions` | Active extractions |
| **Root Directories** | GET | `/{directory}?download` | Download from URL |
| | GET | `/{directory}?downloads` | Download progress |
| | GET | `/{directory}?q` | Search files |
| | GET | `/{directory}?zip` | Create ZIP archive |
| **Root Archives** | GET | `/{archive}?extract` | Extract archive |
| | GET | `/{archive}?extract_file` | Extract single file |
| | GET | `/{archive}?preview` | Preview archive contents |
| | GET | `/{archive}?view_file` | View file from archive |
| **Root Images** | GET | `/{image}?thumbnail` | Image processing |
| **Root Remote** | GET | `/{path}?type=ftp` | FTP access |
| | GET | `/{path}?type=git` | Git access |
| | GET | `/{path}?type=s3` | S3 access |
| | GET | `/{path}?type=ssh` | SSH access |
| | PUT | `/{path}?type=ssh` | Upload via SSH |
| | GET | `/{path}?type=webdav` | WebDAV access |
| **API v1 Backends** | GET | `/api/v1/backends` | List backends |
| | GET | `/api/v1/backends/{id}` | Get backend details |
| | PUT | `/api/v1/backends/{id}` | Update credentials |
| | DELETE | `/api/v1/backends/{id}` | Delete backend |
| | GET | `/api/v1/backends/{id}/test` | Test connection |
| | POST | `/api/v1/backends/{type}` | Create backend (63 types) |
| **API v1 Files** | GET | `/api/v1/files/{path}` | List/Download (JSON) |
| | POST | `/api/v1/files/{path}` | Create dir/Extract/Download |
| | PUT | `/api/v1/files/{path}` | Upload file |
| | PATCH | `/api/v1/files/{path}` | Modify properties |
| | DELETE | `/api/v1/files/{path}` | Delete |
| | PUT | `/api/v1/files/append/{path}` | Append to file |
| | PATCH | `/api/v1/files/chmod/{path}` | Change permissions |
| | PATCH | `/api/v1/files/chown/{path}` | Change ownership |
| | POST | `/api/v1/files/copy/{path}` | Copy file |
| | GET | `/api/v1/files/glob/{path}` | Glob search |
| | GET | `/api/v1/files/grep/{path}` | Content search |
| | GET | `/api/v1/files/health` | Health check |
| | POST | `/api/v1/files/move/{path}` | Move file |
| | GET | `/api/v1/files/realpath/{path}` | Resolve path |
| | GET | `/api/v1/files/stat/{path}` | File stats |
| **API v1 Downloads** | GET | `/api/v1/downloads` | Download progress |
| **API v1 Extractions** | GET | `/api/v1/extractions` | Extraction progress |
| **API v1 Journal** | GET | `/api/v1/journal` | Query journal |
| | POST | `/api/v1/journal/flush` | Flush journal |
| | GET | `/api/v1/journal/stats` | Journal statistics |
| **API v1 Mounts** | GET | `/api/v1/mounts` | List mounts |
| | POST | `/api/v1/mounts` | Create mount |
| | GET | `/api/v1/mounts/{id}` | Get mount details |
| | PATCH | `/api/v1/mounts/{id}` | Update mount config |
| | DELETE | `/api/v1/mounts/{id}` | Remove mount |
| **API v1 System** | GET | `/api/v1/version` | Version info |

### Backend Types (63 Total)

| Category | Backends |
|----------|----------|
| **Major Cloud** | s3, google-cloud-storage, azureblob, azurefiles, drive, onedrive, dropbox, box |
| **Decentralized** | storj, tardigrade, sia |
| **OpenStack** | swift |
| **Enterprise** | filescom, filefabric, sharefile, oracleobjectstorage, hdfs, netstorage |
| **European** | koofr, jottacloud, mailru, hidrive, quatrix, zoho |
| **Storage Services** | b2, cloudinary, imagekit, internetarchive, mega, pcloud, putio, qingstor, seafile |
| **File Sharing** | fichier, gofile, linkbox, pikpak, pixeldrain, premiumizeme, ulozto, uptobox |
| **Protocols** | ftp, sftp, smb, webdav, http |
| **Specialized** | protondrive, iclouddrive, sugarsync, opendrive, yandex, google-photos |
| **Virtual/Utility** | alias, cache, chunker, combine, compress, crypt, hasher, memory, union, local |

### Essential Parameters by Group

**File Operations:**
- `path` — File or directory path (required)
- `backend` — Backend ID for remote operations (optional)
- `overwrite` — Boolean to overwrite existing files (copy/move)
- `chmod` — Octal permissions (e.g., 755)
- `chown` — Owner:group (e.g., user:group)
- `append` — Boolean to append instead of overwrite

**Search:**
- `pattern` — Regex pattern for grep
- `context` — Number of context lines for grep
- `q` — Search query for directory search
- `json` — Return JSON instead of HTML

**Archive:**
- `extract` — Extract all or pattern
- `extract_file` — Extract single file
- `preview` — Preview or read from archive
- `view_file` — Read file from archive
- `zip` — Create ZIP from directory
- `destination` — Extraction destination

**Image:**
- `thumbnail` — Enable image processing
- `width` — Resize width
- `height` — Resize height
- `format` — Output format (jpeg, png, webp, gif, bmp)

**Mounts:**
- `label` — Filter mounts by label
- `backend_id` — Backend to mount
- `mount_point` — Local mount path
- `vfs_config` — VFS configuration object

**Journal:**
- `after_id` — Cursor for pagination
- `limit` — Number of entries to return
- `operation` — Filter by operation type
- `path` — Filter by path

### Typical Response Formats

**File Listing:**
```
[
  {
    "name": "file.txt",
    "path": "/dir/file.txt",
    "size": 1234,
    "modified": "2025-01-15T10:30:00Z",
    "is_dir": false
  }
]
```

**File Stats:**
```
{
  "name": "file.txt",
  "path": "/dir/file.txt",
  "size": 1234,
  "modified": "2025-01-15T10:30:00Z",
  "is_dir": false,
  "permissions": "0644",
  "owner": "user",
  "group": "group"
}
```

**Backend List:**
```
[
  {
    "id": "my-backend",
    "type": "s3",
    "name": "My S3 Bucket",
    "status": "connected"
  }
]
```

**Mount List:**
```
[
  {
    "id": "mount-abc123",
    "backend_id": "my-backend",
    "mount_point": "/mnt/my-backend",
    "status": "mounted"
  }
]
```

**Journal Entry:**
```
{
  "id": "entry-123",
  "timestamp": "2025-01-15T10:30:00Z",
  "operation": "write",
  "path": "/dir/file.txt",
  "size": 1234,
  "backend": "my-backend"
}
```

**Health Check:**
```
{
  "status": "healthy",
  "service": "hoody-files",
  "version": "1.0.0",
  "uptime_seconds": 86400
}
```

### Base URL Pattern

```
https://{projectId}-{containerId}-files-{serviceId}.{node}.containers.hoody.com
```

Replace placeholders with actual values from your Hoody project configuration. The service ID and node are obtained during container creation via the Hoody API.