/api/program/on-usb

# Check if running from USB drive
curl -X GET "http://localhost:8080/api/program/on-usb"

# With formatted output using jq
curl -X GET "http://localhost:8080/api/program/on-usb" | jq '.'

# Check USB status and extract boolean value
curl -s "http://localhost:8080/api/program/on-usb" | jq -r '.on_usb'

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

const ApiHost = "http://localhost:8080"

type USBResponse struct {
    Status    string `json:"status"`
    Operation string `json:"operation"`
    OnUSB     bool   `json:"on_usb"`
    RootPath  string `json:"root_path"`
}

func main() {
    resp, err := http.Get(fmt.Sprintf("%s/api/program/on-usb", ApiHost))
    if err != nil {
        log.Fatalf("Failed to check USB status: %v", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalf("Failed to read response: %v", err)
    }

    var result USBResponse
    if err := json.Unmarshal(body, &result); err != nil {
        log.Fatalf("Failed to parse JSON: %v", err)
    }

    fmt.Printf("CloudCoin Console Location: %s\n", result.RootPath)

    if result.OnUSB {
        fmt.Println("⚠️  Running from USB drive (removable storage)")
        fmt.Println("Security Recommendations:")
        fmt.Println("  - Keep your USB drive physically secure")
        fmt.Println("  - Maintain encrypted backups on separate storage")
        fmt.Println("  - Use 'Safely Eject' before removing USB")
        fmt.Println("  - Consider using AES-256 encryption for wallet files")

        // Adjust settings for portable mode
        enablePortableMode()
    } else {
        fmt.Println("✓ Running from internal/fixed storage")

        // Use standard configuration
        enableStandardMode()
    }
}

func enablePortableMode() {
    // Reduce caching to minimize data loss on sudden USB removal
    fmt.Println("\nEnabling portable mode:")
    fmt.Println("  - Aggressive auto-save: Every 30 seconds")
    fmt.Println("  - Reduced cache size: 10 MB")
    fmt.Println("  - Safe-eject monitoring: Enabled")
}

func enableStandardMode() {
    fmt.Println("\nUsing standard mode:")
    fmt.Println("  - Auto-save: Every 5 minutes")
    fmt.Println("  - Cache size: 100 MB")
}

import requests
import json
from datetime import datetime

API_HOST = 'http://localhost:8080'

def check_usb_storage():
    """Check if CloudCoin Console is running from USB drive"""
    try:
        response = requests.get(f'{API_HOST}/api/program/on-usb')
        result = response.json()

        on_usb = result.get('on_usb', False)
        root_path = result.get('root_path', 'Unknown')

        print(f'CloudCoin Location: {root_path}')
        print(f'USB Drive: {"Yes" if on_usb else "No"}')
        print()

        if on_usb:
            print('⚠️  PORTABLE WALLET DETECTED')
            print('=' * 50)
            print('Security Recommendations:')
            print('  1. Enable wallet encryption (AES-256)')
            print('  2. Maintain cloud/desktop backups')
            print('  3. Use "Safely Eject" before removing USB')
            print('  4. Keep USB drive in secure location')
            print('  5. Consider using a hardware wallet lock')
            print()

            # Configure for USB mode
            config = get_usb_configuration()
            apply_configuration(config)
        else:
            print('✓ Standard Installation')
            print('Using default desktop configuration')
            print()

            config = get_standard_configuration()
            apply_configuration(config)

        return result

    except requests.exceptions.RequestException as e:
        print(f'Error checking USB status: {e}')
        return None

def get_usb_configuration():
    """Get optimized configuration for USB drives"""
    return {
        'auto_save_interval': 30,  # seconds
        'cache_size_mb': 10,
        'enable_safe_eject_monitor': True,
        'io_buffer_size': 4096,  # Smaller buffer for USB 2.0
        'encryption_recommended': True,
        'backup_reminder_frequency': 'daily'
    }

def get_standard_configuration():
    """Get standard configuration for internal drives"""
    return {
        'auto_save_interval': 300,  # 5 minutes
        'cache_size_mb': 100,
        'enable_safe_eject_monitor': False,
        'io_buffer_size': 65536,  # Larger buffer for SSDs
        'encryption_recommended': False,
        'backup_reminder_frequency': 'weekly'
    }

def apply_configuration(config):
    """Apply configuration settings"""
    print('Configuration Applied:')
    for key, value in config.items():
        print(f'  {key}: {value}')

def monitor_usb_ejection():
    """Monitor for USB drive removal (Windows only)"""
    import time

    print('\nMonitoring USB drive (Press Ctrl+C to stop)...')

    try:
        while True:
            response = requests.get(f'{API_HOST}/api/program/on-usb')
            result = response.json()

            if not result.get('on_usb', True):
                print(f'\n[{datetime.now()}] WARNING: USB drive removed!')
                print('Wallet may no longer be accessible.')
                break

            time.sleep(5)  # Check every 5 seconds

    except KeyboardInterrupt:
        print('\nMonitoring stopped.')

if __name__ == '__main__':
    result = check_usb_storage()

    if result and result.get('on_usb'):
        # Optionally start USB ejection monitoring
        monitor = input('\nStart USB ejection monitoring? (y/n): ')
        if monitor.lower() == 'y':
            monitor_usb_ejection()