Tauri Commands

Complete reference for all Tauri commands exposed to the frontend

ZipDrop exposes several Tauri commands that the frontend can invoke to interact with the Rust backend.

Core Workflow

process_and_upload

Main command that processes files and uploads them to R2 or saves locally in demo mode.

#[tauri::command]
async fn process_and_upload(
    state: tauri::State<'_, AppState>,
    paths: Vec<String>,
) -> Result<DropResult, String>

state · AppState · required

Application state containing R2 config and settings

paths · Vec<String> · required

Array of file paths (as strings) to process and upload

Returns: Result<DropResult, String>

DropResult Structure

url · String · required

Public URL to access the uploaded file. Format: https://your-domain.com/u/{key} for R2 uploads, or file:///path/to/file for demo mode

local_path · Option<String>

Path to the local file (only set in demo mode)

r2_key · Option<String>

R2 object key (only set when uploaded to R2)

original_size · u64 · required

Total size of original file(s) in bytes

processed_size · u64 · required

Size of processed file in bytes

file_type · String · required

File extension of the output (“webp”, “zip”, etc.)

is_demo · bool · required

Whether the file was processed in demo mode

Workflow:

1. Checks if demo mode is enabled
2. Determines output directory (Downloads/ZipDrop for demo, /tmp/zipdrop for production)
3. Processes files (convert to WebP or ZIP)
4. Either:
   • Demo mode: Saves to Downloads/ZipDrop, copies local path to clipboard
   • Production mode: Uploads to R2, copies public URL to clipboard
5. Returns DropResult with all metadata

Example Invocation (JavaScript):

Demo Mode

const result = await invoke('process_and_upload', {
  paths: ['/Users/john/Desktop/photo.jpg']
});

// Result:
// {
//   url: "file:///Users/john/Downloads/ZipDrop/photo_a1b2c3d4.webp",
//   local_path: "/Users/john/Downloads/ZipDrop/photo_a1b2c3d4.webp",
//   r2_key: null,
//   original_size: 2500000,
//   processed_size: 850000,
//   file_type: "webp",
//   is_demo: true
// }

Error Cases:

• Empty paths array: "No files provided"
• Validation failures: See File Processing errors
• R2 not configured (production mode): "R2 not configured. Please set up your R2 credentials or enable demo mode."
• Upload failures: Network or credential errors from R2

Configuration Management

set_r2_config

Saves R2 configuration to macOS Keychain and updates app state.

#[tauri::command]
fn set_r2_config(state: tauri::State<'_, AppState>, config: R2Config) -> Result<(), String>

state · AppState · required

Application state

config · R2Config · required

R2 configuration object with all credentials

R2Config Structure:

access_key · String · required

R2 access key ID

secret_key · String · required

R2 secret access key

bucket_name · String · required

R2 bucket name

account_id · String · required

Cloudflare account ID

public_url_base · String · required

Base URL for public access (e.g., https://files.example.com)

Side Effects:

• Saves credentials to macOS Keychain (secure storage)
• Saves non-secret config to ~/Library/Application Support/zipdrop/config.json
• Automatically disables demo mode
• Updates in-memory app state

Example Invocation:

await invoke('set_r2_config', {
  config: {
    access_key: 'your-access-key',
    secret_key: 'your-secret-key',
    bucket_name: 'my-bucket',
    account_id: 'abc123def456',
    public_url_base: 'https://files.example.com'
  }
});

get_r2_config

Retrieves the current R2 configuration (for populating settings forms).

#[tauri::command]
fn get_r2_config(state: tauri::State<'_, AppState>) -> Option<R2Config>

Returns: Option<R2Config> - Configuration if set, null if not configured

Example:

const config = await invoke('get_r2_config');
if (config) {
  // Populate form with config.bucket_name, etc.
}

get_config_status

Returns the current configuration status (lighter weight than get_r2_config).

#[tauri::command]
fn get_config_status(state: tauri::State<'_, AppState>) -> ConfigStatus

ConfigStatus Structure:

is_configured · bool · required

Whether R2 credentials are configured

demo_mode · bool · required

Whether demo mode is enabled

bucket_name · Option<String>

Current bucket name if configured

Example:

const status = await invoke('get_config_status');
// { is_configured: true, demo_mode: false, bucket_name: "my-bucket" }

clear_r2_config

Deletes R2 configuration from Keychain and file system.

#[tauri::command]
fn clear_r2_config(state: tauri::State<'_, AppState>) -> Result<(), String>

Side Effects:

• Removes credentials from macOS Keychain
• Deletes ~/Library/Application Support/zipdrop/config.json
• Clears in-memory app state

Example:

await invoke('clear_r2_config');

validate_r2_config

Validates R2 credentials before saving by uploading a test object.

#[tauri::command]
async fn validate_r2_config(config: R2Config) -> Result<(), String>

config · R2Config · required

R2 configuration to validate

Validation Process:

1. Creates S3/R2 client with provided credentials
2. Uploads tiny test object (.zipdrop-connection-test)
3. Deletes test object if upload succeeds
4. Returns error if any step fails

Error Messages:

• "Connection timed out - please try again" - Network timeout
• "Connection failed - check your network" - Network unreachable
• "Invalid R2 credentials" - Auth failure or other error

Example:

try {
  await invoke('validate_r2_config', { config });
  // Credentials are valid, proceed with set_r2_config
} catch (error) {
  // Show error to user
}

Settings

set_demo_mode

Enables or disables demo mode.

#[tauri::command]
fn set_demo_mode(state: tauri::State<'_, AppState>, enabled: bool) -> Result<(), String>

enabled · bool · required

Whether to enable demo mode

Side Effects:

• Updates ~/Library/Application Support/zipdrop/settings.json
• Updates in-memory app state

Example:

await invoke('set_demo_mode', { enabled: true });

Utility Commands

copy_to_clipboard

Copies text to the system clipboard.

#[tauri::command]
fn copy_to_clipboard(text: String) -> Result<(), String>

text · String · required

Text to copy to clipboard

Example:

await invoke('copy_to_clipboard', { 
  text: 'https://files.example.com/u/file.zip' 
});

reveal_in_finder

Opens Finder and selects the specified file.

#[tauri::command]
fn reveal_in_finder(path: String) -> Result<(), String>

path · String · required

Absolute path to the file to reveal

Example:

await invoke('reveal_in_finder', { 
  path: '/Users/john/Downloads/ZipDrop/file.webp' 
});

open_in_browser

Opens a URL in the default browser.

#[tauri::command]
fn open_in_browser(url: String) -> Result<(), String>

url · String · required

URL to open

Example:

await invoke('open_in_browser', { 
  url: 'https://files.example.com/u/file.zip' 
});

delete_from_r2

Deletes an object from R2 storage.

#[tauri::command]
async fn delete_from_r2(state: tauri::State<'_, AppState>, key: String) -> Result<(), String>

state · AppState · required

Application state containing R2 config

key · String · required

R2 object key to delete (e.g., "u/x7y8z9w0_file.zip")

Example:

await invoke('delete_from_r2', { 
  key: 'u/x7y8z9w0_file.zip' 
});

This command is fire-and-forget. Errors are logged but the operation continues. Use for cleanup when you don’t need to guarantee deletion.

App State

All commands that require state access the global AppState structure:

pub struct AppState {
    pub r2_config: Mutex<Option<R2Config>>,
    pub settings: Mutex<AppSettings>,
}

r2_config · Mutex<Option<R2Config>> · required

Thread-safe R2 configuration (None if not configured)

settings · Mutex<AppSettings> · required

Thread-safe app settings (demo mode, output directory)

State is managed by Tauri and automatically injected into command handlers. Frontend code doesn’t need to pass state explicitly.