style: reformat codebase with oxfmt

docs/FEATURE_FLAGS.md

@@ -17,19 +17,19 @@ sequenceDiagram
 
     Frontend->>WebSocket: Connect
     WebSocket-->>Frontend: Connection established
-    
+
     Note over Frontend: First message must be feature flags
     Frontend->>WebSocket: Send client feature flags
     WebSocket->>Backend: Receive feature flags
     Backend->>FeatureFlags Module: Store client capabilities
-    
+
     Backend->>FeatureFlags Module: Get server features
     FeatureFlags Module-->>Backend: Return server capabilities
     Backend->>WebSocket: Send server feature flags
     WebSocket-->>Frontend: Receive server features
-    
+
     Note over Frontend,Backend: Both sides now know each other's capabilities
-    
+
     Frontend->>Frontend: Store server features
     Frontend->>Frontend: Components use useFeatureFlags()
 ```
@@ -44,15 +44,15 @@ graph TB
         D[useFeatureFlags composable] --> B
         E[Vue Components] --> D
     end
-    
+
     subgraph Backend
         F[feature_flags.py] --> G[SERVER_FEATURE_FLAGS]
         H[server.py WebSocket] --> F
         I[Feature Consumers] --> F
     end
-    
+
     C <--> H
-    
+
     style A fill:#f9f,stroke:#333,stroke-width:2px
     style G fill:#f9f,stroke:#333,stroke-width:2px
     style D fill:#9ff,stroke:#333,stroke-width:2px
@@ -98,19 +98,19 @@ classDiagram
         +supports_feature(sockets_metadata, sid, feature_name) bool
         +get_connection_feature(sockets_metadata, sid, feature_name, default) Any
     }
-    
+
     class PromptServer {
         -sockets_metadata: Dict
         +websocket_handler()
         +send()
     }
-    
+
     class FeatureConsumer {
         <<interface>>
         +check_feature()
         +use_feature()
     }
-    
+
     PromptServer --> FeatureFlagsModule
     FeatureConsumer --> FeatureFlagsModule
 ```
@@ -127,19 +127,19 @@ classDiagram
         +serverSupportsFeature(name) boolean
         +getServerFeature(name, default) T
     }
-    
+
     class useFeatureFlags {
         +serverSupports(name) boolean
         +getServerFeature(name, default) T
         +createServerFeatureFlag(name) ComputedRef
         +extension: ExtensionFlags
     }
-    
+
     class VueComponent {
         <<component>>
         +setup()
     }
-    
+
     ComfyApi <-- useFeatureFlags
     VueComponent --> useFeatureFlags
 ```
@@ -153,12 +153,13 @@ graph LR
     A[Preview Generation] --> B{supports_preview_metadata?}
     B -->|Yes| C[Send metadata with preview]
     B -->|No| D[Send preview only]
-    
+
     C --> E[Enhanced preview with node info]
     D --> F[Basic preview image]
 ```
 
 **Backend Usage:**
+
 ```python
 # Check if client supports preview metadata
 if feature_flags.supports_feature(
@@ -189,13 +190,14 @@ graph TB
     B --> C{File size OK?}
     C -->|Yes| D[Upload file]
     C -->|No| E[Show error]
-    
+
     F[Backend] --> G[Set from CLI args]
     G --> H[Convert MB to bytes]
     H --> I[Include in feature flags]
 ```
 
 **Backend Configuration:**
+
 ```python
 # In feature_flags.py
 SERVER_FEATURE_FLAGS = {
@@ -205,6 +207,7 @@ SERVER_FEATURE_FLAGS = {
 ```
 
 **Frontend Usage:**
+
 ```typescript
 const { getServerFeature } = useFeatureFlags()
 const maxUploadSize = getServerFeature('max_upload_size', 100 * 1024 * 1024) // Default 100MB
@@ -215,10 +218,11 @@ const maxUploadSize = getServerFeature('max_upload_size', 100 * 1024 * 1024) //
 ### Frontend Access Patterns
 
 1. **Direct API access:**
+
 ```typescript
 // Check boolean feature
 if (api.serverSupportsFeature('supports_preview_metadata')) {
-    // Feature is supported
+  // Feature is supported
 }
 
 // Get feature value with default
@@ -226,21 +230,23 @@ const maxSize = api.getServerFeature('max_upload_size', 100 * 1024 * 1024)
 ```
 
 2. **Using the composable (recommended for reactive components):**
+
 ```typescript
 const { serverSupports, getServerFeature, extension } = useFeatureFlags()
 
 // Check feature support
 if (serverSupports('supports_preview_metadata')) {
-    // Use enhanced previews
+  // Use enhanced previews
 }
 
 // Use reactive convenience properties (automatically update if flags change)
 if (extension.manager.supportsV4.value) {
-    // Use V4 manager API
+  // Use V4 manager API
 }
 ```
 
 3. **Reactive usage in templates:**
+
 ```vue
 <template>
   <div v-if="featureFlags.extension.manager.supportsV4">
@@ -262,12 +268,12 @@ const featureFlags = useFeatureFlags()
 ```python
 # Check if a specific client supports a feature
 if feature_flags.supports_feature(
-    sockets_metadata, 
-    client_id, 
+    sockets_metadata,
+    client_id,
     "supports_preview_metadata"
 ):
     # Client supports this feature
-    
+
 # Get feature value with default
 max_size = feature_flags.get_connection_feature(
     sockets_metadata,
@@ -282,6 +288,7 @@ max_size = feature_flags.get_connection_feature(
 ### Backend
 
 1. **For server capabilities**, add to `SERVER_FEATURE_FLAGS` in `comfy_api/feature_flags.py`:
+
 ```python
 SERVER_FEATURE_FLAGS = {
     "supports_preview_metadata": True,
@@ -291,6 +298,7 @@ SERVER_FEATURE_FLAGS = {
 ```
 
 2. **Use in your code:**
+
 ```python
 if feature_flags.supports_feature(sockets_metadata, sid, "your_new_feature"):
     # Feature-specific code
@@ -299,28 +307,34 @@ if feature_flags.supports_feature(sockets_metadata, sid, "your_new_feature"):
 ### Frontend
 
 1. **For client capabilities**, add to `src/config/clientFeatureFlags.json`:
+
 ```json
 {
-    "supports_preview_metadata": false,
-    "your_new_feature": true
+  "supports_preview_metadata": false,
+  "your_new_feature": true
 }
 ```
 
 2. **For extension features**, update the composable to add convenience accessors:
+
 ```typescript
 // In useFeatureFlags.ts
 const extension = {
-    manager: {
-        supportsV4: computed(() => getServerFeature('extension.manager.supports_v4', false))
-    },
-    yourExtension: {
-        supportsNewFeature: computed(() => getServerFeature('extension.yourExtension.supports_new_feature', false))
-    }
+  manager: {
+    supportsV4: computed(() =>
+      getServerFeature('extension.manager.supports_v4', false)
+    )
+  },
+  yourExtension: {
+    supportsNewFeature: computed(() =>
+      getServerFeature('extension.yourExtension.supports_new_feature', false)
+    )
+  }
 }
 
 return {
-    // ... existing returns
-    extension
+  // ... existing returns
+  extension
 }
 ```
 
@@ -332,7 +346,7 @@ graph LR
     A --> C[Only frontend supports]
     A --> D[Only backend supports]
     A --> E[Neither supports]
-    
+
     B --> F[Feature enabled]
     C --> G[Feature disabled]
     D --> H[Feature disabled]
@@ -340,6 +354,7 @@ graph LR
 ```
 
 Test your feature flags with different combinations:
+
 - Frontend with flag + Backend with flag = Feature works
 - Frontend with flag + Backend without = Graceful degradation
 - Frontend without + Backend with flag = No feature usage
@@ -350,13 +365,14 @@ Test your feature flags with different combinations:
 ```typescript
 // In tests-ui/tests/api.featureFlags.test.ts
 it('should handle preview metadata based on feature flag', () => {
-    // Mock server supports feature
-    api.serverFeatureFlags = { supports_preview_metadata: true }
-    
-    expect(api.serverSupportsFeature('supports_preview_metadata')).toBe(true)
-    
-    // Mock server doesn't support feature
-    api.serverFeatureFlags = {}
-    
-    expect(api.serverSupportsFeature('supports_preview_metadata')).toBe(false)
-})
+  // Mock server supports feature
+  api.serverFeatureFlags = { supports_preview_metadata: true }
+
+  expect(api.serverSupportsFeature('supports_preview_metadata')).toBe(true)
+
+  // Mock server doesn't support feature
+  api.serverFeatureFlags = {}
+
+  expect(api.serverSupportsFeature('supports_preview_metadata')).toBe(false)
+})
+```