@redseat/api 0.3.12 → 0.3.14

package/client.md

@@ -329,6 +329,12 @@ Connects to the server's SSE endpoint for real-time updates.
   - `maxReconnectAttempts?`: Maximum reconnect attempts (default: unlimited)
   - `initialReconnectDelay?`: Initial reconnect delay in ms (default: `1000`)
   - `maxReconnectDelay?`: Maximum reconnect delay in ms (default: `30000`)
+  - `reconnectOnPageVisible?`: Reconnect when tab becomes visible after being hidden (default: `true`)
+  - `reconnectVisibleAfterMs?`: Minimum hidden duration before reconnect on visible (default: `30000`)
+  - `reconnectOnOnline?`: Reconnect when browser goes online (default: `true`)
+  - `reconnectOnFocus?`: Reconnect on window focus when connection is unhealthy (default: `true`)
+  - `reconnectOnAuthError?`: Retry reconnect after auth (`401`) errors (default: `true`)
+  - `maxAuthReconnectAttempts?`: Maximum auth reconnect attempts (default: `5`)
 
 **Example:**
 ```typescript
@@ -345,7 +351,9 @@ await client.connectSSE({
     autoReconnect: true,
     maxReconnectAttempts: 10,
     initialReconnectDelay: 2000,
-    maxReconnectDelay: 60000
+    maxReconnectDelay: 60000,
+    reconnectOnPageVisible: true,
+    reconnectVisibleAfterMs: 45000
 });
 ```
 
@@ -667,4 +675,3 @@ client.dispose();
 - [ServerApi Documentation](server.md) - Uses RedseatClient for server operations
 - [LibraryApi Documentation](libraries.md) - Uses RedseatClient for library operations
 - [README](README.md) - Package overview
-

package/dist/client.d.ts

@@ -5,7 +5,7 @@ import { IServer } from './interfaces.js';
 import { SSEConnectionState, SSEConnectionOptions, SSEConnectionError, SSELibraryEvent, SSELibraryStatusEvent, SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSEBackupsEvent, SSEBackupFilesEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSEPlayersListEvent, SSEWatchedEvent, SSEUnwatchedEvent, SSERequestProcessingEvent } from './sse-types.js';
 export interface ClientOptions {
     server: IServer;
-    getIdToken: () => Promise<string>;
+    getIdToken: (forceRefresh?: boolean) => Promise<string>;
     refreshThreshold?: number;
     timeout?: number;
     redseatUrl?: string;
@@ -24,8 +24,15 @@ export declare class RedseatClient {
     private disposed;
     private sseAbortController?;
     private sseReconnectTimeout?;
+    private sseActivityTimeout?;
     private sseReconnectAttempts;
+    private sseAuthReconnectAttempts;
     private sseOptions?;
+    private sseShouldReconnect;
+    private sseIsConnecting;
+    private sseLifecycleRegistered;
+    private sseHiddenAt?;
+    private readonly SSE_ACTIVITY_TIMEOUT;
     private readonly _sseConnectionState;
     private readonly _sseError;
     private readonly _sseEvents;
@@ -94,6 +101,15 @@ export declare class RedseatClient {
      * Returns public server info (IServer).
      */
     getServer(serverId: string): Promise<IServer>;
+    private readonly onDocumentVisibilityChange;
+    private readonly onWindowPageShow;
+    private readonly onWindowOnline;
+    private readonly onWindowFocus;
+    private shouldAttemptReconnect;
+    private clearSSEReconnectTimeout;
+    private registerSSELifecycleListeners;
+    private unregisterSSELifecycleListeners;
+    private forceReconnectSSE;
     /**
      * Connects to the server's SSE endpoint for real-time updates.
      * Automatically manages authentication and reconnection.
@@ -121,6 +137,16 @@ export declare class RedseatClient {
      * Builds the SSE endpoint URL with optional library filters
      */
     private buildSSEUrl;
+    /**
+     * Resets the activity timeout timer.
+     * Called when data is received from the SSE stream.
+     * If no data is received within the timeout period, triggers reconnection.
+     */
+    private resetActivityTimeout;
+    /**
+     * Clears the activity timeout timer.
+     */
+    private clearActivityTimeout;
     /**
      * Processes the SSE stream and emits events
      */

package/dist/client.js

@@ -38,6 +38,11 @@ export class RedseatClient {
     constructor(options) {
         this.disposed = false;
         this.sseReconnectAttempts = 0;
+        this.sseAuthReconnectAttempts = 0;
+        this.sseShouldReconnect = false;
+        this.sseIsConnecting = false;
+        this.sseLifecycleRegistered = false;
+        this.SSE_ACTIVITY_TIMEOUT = 90000; // 90 seconds - reconnect if no data received
         // RxJS subjects for SSE
         this._sseConnectionState = new BehaviorSubject('disconnected');
         this._sseError = new Subject();
@@ -65,6 +70,62 @@ export class RedseatClient {
         this.watched$ = this.createEventStream('watched');
         this.unwatched$ = this.createEventStream('unwatched');
         this.requestProcessing$ = this.createEventStream('request_processing');
+        // ==================== SSE Methods ====================
+        this.onDocumentVisibilityChange = () => {
+            if (!this.shouldAttemptReconnect() || typeof document === 'undefined') {
+                return;
+            }
+            if (document.visibilityState === 'hidden') {
+                this.sseHiddenAt = Date.now();
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnPageVisible ?? true)) {
+                return;
+            }
+            const hiddenAt = this.sseHiddenAt;
+            this.sseHiddenAt = undefined;
+            if (hiddenAt === undefined) {
+                return;
+            }
+            const hiddenDuration = Date.now() - hiddenAt;
+            const minHiddenDuration = this.sseOptions?.reconnectVisibleAfterMs ?? 30000;
+            if (hiddenDuration >= minHiddenDuration) {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowPageShow = (event) => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnPageVisible ?? true)) {
+                return;
+            }
+            if (event.persisted || this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowOnline = () => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnOnline ?? true)) {
+                return;
+            }
+            if (this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowFocus = () => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnFocus ?? true)) {
+                return;
+            }
+            if (this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
         this.server = options.server;
         this.redseatUrl = options.redseatUrl;
         this.getIdToken = options.getIdToken;
@@ -167,7 +228,8 @@ export class RedseatClient {
         }
         this.tokenRefreshPromise = (async () => {
             try {
-                const idToken = await this.getIdToken();
+                // Force refresh the Firebase idToken to ensure it's not stale/cached
+                const idToken = await this.getIdToken(true);
                 // Use fetchServerToken which uses the global axios instance
                 // The token endpoint is on the frontend server, not the backend server
                 const newToken = await fetchServerToken(this.serverId, idToken, this.redseatUrl);
@@ -280,7 +342,52 @@ export class RedseatClient {
         });
         return response.data;
     }
-    // ==================== SSE Methods ====================
+    shouldAttemptReconnect() {
+        return !this.disposed && this.sseShouldReconnect && (this.sseOptions?.autoReconnect ?? true);
+    }
+    clearSSEReconnectTimeout() {
+        if (this.sseReconnectTimeout) {
+            clearTimeout(this.sseReconnectTimeout);
+            this.sseReconnectTimeout = undefined;
+        }
+    }
+    registerSSELifecycleListeners() {
+        if (this.sseLifecycleRegistered || typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        document.addEventListener('visibilitychange', this.onDocumentVisibilityChange);
+        window.addEventListener('pageshow', this.onWindowPageShow);
+        window.addEventListener('online', this.onWindowOnline);
+        window.addEventListener('focus', this.onWindowFocus);
+        this.sseLifecycleRegistered = true;
+        if (document.visibilityState === 'hidden') {
+            this.sseHiddenAt = Date.now();
+        }
+    }
+    unregisterSSELifecycleListeners() {
+        if (!this.sseLifecycleRegistered || typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        document.removeEventListener('visibilitychange', this.onDocumentVisibilityChange);
+        window.removeEventListener('pageshow', this.onWindowPageShow);
+        window.removeEventListener('online', this.onWindowOnline);
+        window.removeEventListener('focus', this.onWindowFocus);
+        this.sseLifecycleRegistered = false;
+        this.sseHiddenAt = undefined;
+    }
+    forceReconnectSSE() {
+        if (!this.shouldAttemptReconnect()) {
+            return;
+        }
+        this.clearSSEReconnectTimeout();
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = undefined;
+        }
+        this.sseReconnectAttempts = 0;
+        this._sseConnectionState.next('reconnecting');
+        void this._connectSSE();
+    }
     /**
      * Connects to the server's SSE endpoint for real-time updates.
      * Automatically manages authentication and reconnection.
@@ -293,23 +400,34 @@ export class RedseatClient {
             autoReconnect: true,
             initialReconnectDelay: 1000,
             maxReconnectDelay: 30000,
+            reconnectOnPageVisible: true,
+            reconnectVisibleAfterMs: 30000,
+            reconnectOnOnline: true,
+            reconnectOnFocus: true,
+            reconnectOnAuthError: true,
+            maxAuthReconnectAttempts: 5,
             ...options
         };
         this.sseReconnectAttempts = 0;
+        this.sseAuthReconnectAttempts = 0;
+        this.sseShouldReconnect = true;
+        this.registerSSELifecycleListeners();
         await this._connectSSE();
     }
     /**
      * Disconnects from the SSE endpoint and cleans up resources.
      */
     disconnectSSE() {
-        if (this.sseReconnectTimeout) {
-            clearTimeout(this.sseReconnectTimeout);
-            this.sseReconnectTimeout = undefined;
-        }
+        this.sseShouldReconnect = false;
+        this.sseIsConnecting = false;
+        this.sseAuthReconnectAttempts = 0;
+        this.clearSSEReconnectTimeout();
+        this.clearActivityTimeout();
         if (this.sseAbortController) {
             this.sseAbortController.abort();
             this.sseAbortController = undefined;
         }
+        this.unregisterSSELifecycleListeners();
         this._sseConnectionState.next('disconnected');
     }
     /**
@@ -335,6 +453,14 @@ export class RedseatClient {
      * Internal method to establish SSE connection
      */
     async _connectSSE() {
+        if (this.disposed || !this.sseShouldReconnect || this.sseIsConnecting) {
+            return;
+        }
+        if (this.sseConnectionState === 'connected' && this.sseAbortController) {
+            return;
+        }
+        this.clearSSEReconnectTimeout();
+        this.sseIsConnecting = true;
         this._sseConnectionState.next('connecting');
         try {
             // Ensure we have a valid token
@@ -343,28 +469,54 @@ export class RedseatClient {
                 throw new Error('No authentication token available');
             }
             const url = this.buildSSEUrl();
-            this.sseAbortController = new AbortController();
+            const abortController = new AbortController();
+            this.sseAbortController = abortController;
             console.log("SSSEEEE URL", url);
-            const response = await fetch(url, {
+            let response = await fetch(url, {
                 method: 'GET',
                 headers: {
                     'Authorization': `Bearer ${this.tokenData.token}`,
                     'Accept': 'text/event-stream',
                     'Cache-Control': 'no-cache'
                 },
-                signal: this.sseAbortController.signal
+                signal: abortController.signal
             });
             if (!response.ok) {
                 if (response.status === 401) {
-                    throw Object.assign(new Error('Authentication failed'), { type: 'auth' });
+                    // Try refreshing token and retry ONCE before giving up
+                    try {
+                        console.log('SSE 401 - attempting token refresh and retry');
+                        await this.refreshToken();
+                        // Retry the connection with the fresh token
+                        const retryResponse = await fetch(url, {
+                            method: 'GET',
+                            headers: {
+                                'Authorization': `Bearer ${this.tokenData.token}`,
+                                'Accept': 'text/event-stream',
+                                'Cache-Control': 'no-cache'
+                            },
+                            signal: this.sseAbortController.signal
+                        });
+                        if (!retryResponse.ok) {
+                            throw Object.assign(new Error('Authentication failed after token refresh'), { type: 'auth' });
+                        }
+                        // Use the retry response instead
+                        response = retryResponse;
+                    }
+                    catch (retryError) {
+                        throw Object.assign(new Error('Authentication failed'), { type: 'auth' });
+                    }
+                }
+                else {
+                    throw Object.assign(new Error(`Server returned ${response.status}`), { type: 'server' });
                 }
-                throw Object.assign(new Error(`Server returned ${response.status}`), { type: 'server' });
             }
             if (!response.body) {
                 throw Object.assign(new Error('No response body'), { type: 'server' });
             }
             this._sseConnectionState.next('connected');
             this.sseReconnectAttempts = 0;
+            this.sseAuthReconnectAttempts = 0;
             // Process the stream in the background (don't await - it runs forever until disconnected)
             this.processSSEStream(response.body).catch(err => {
                 if (err?.name !== 'AbortError') {
@@ -377,8 +529,12 @@ export class RedseatClient {
                 // Intentionally disconnected
                 return;
             }
+            this.sseAbortController = undefined;
             this.handleSSEError(error);
         }
+        finally {
+            this.sseIsConnecting = false;
+        }
     }
     /**
      * Builds the SSE endpoint URL with optional library filters
@@ -392,6 +548,39 @@ export class RedseatClient {
         }
         return url;
     }
+    /**
+     * Resets the activity timeout timer.
+     * Called when data is received from the SSE stream.
+     * If no data is received within the timeout period, triggers reconnection.
+     */
+    resetActivityTimeout() {
+        if (this.sseActivityTimeout) {
+            clearTimeout(this.sseActivityTimeout);
+        }
+        this.sseActivityTimeout = setTimeout(() => {
+            if (this.disposed) {
+                return;
+            }
+            // No activity within timeout period - connection is likely stale
+            console.log('SSE activity timeout - reconnecting');
+            this._sseConnectionState.next('disconnected');
+            // Abort current connection and schedule reconnect
+            if (this.sseAbortController) {
+                this.sseAbortController.abort();
+                this.sseAbortController = undefined;
+            }
+            this.scheduleReconnect();
+        }, this.SSE_ACTIVITY_TIMEOUT);
+    }
+    /**
+     * Clears the activity timeout timer.
+     */
+    clearActivityTimeout() {
+        if (this.sseActivityTimeout) {
+            clearTimeout(this.sseActivityTimeout);
+            this.sseActivityTimeout = undefined;
+        }
+    }
     /**
      * Processes the SSE stream and emits events
      */
@@ -399,15 +588,22 @@ export class RedseatClient {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
+        // Start activity timeout tracking
+        this.resetActivityTimeout();
         try {
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) {
                     // Stream ended - server closed connection
+                    this.clearActivityTimeout();
                     this._sseConnectionState.next('disconnected');
-                    this.scheduleReconnect();
+                    if (this.shouldAttemptReconnect()) {
+                        this.scheduleReconnect();
+                    }
                     break;
                 }
+                // Data received - reset activity timeout
+                this.resetActivityTimeout();
                 buffer += decoder.decode(value, { stream: true });
                 const { events, remainingBuffer } = this.parseSSEBuffer(buffer);
                 buffer = remainingBuffer;
@@ -418,12 +614,14 @@ export class RedseatClient {
             }
         }
         catch (error) {
+            this.clearActivityTimeout();
             if (error instanceof Error && error.name === 'AbortError') {
                 return;
             }
             throw error;
         }
         finally {
+            this.sseAbortController = undefined;
             reader.releaseLock();
         }
     }
@@ -497,6 +695,9 @@ export class RedseatClient {
      * Handles SSE errors and triggers reconnection if appropriate
      */
     handleSSEError(error) {
+        if (this.disposed || !this.sseShouldReconnect) {
+            return;
+        }
         const sseError = {
             type: 'network',
             message: error instanceof Error ? error.message : 'Unknown error',
@@ -509,40 +710,68 @@ export class RedseatClient {
         }
         this._sseConnectionState.next('error');
         this._sseError.next(sseError);
-        // Don't reconnect on auth errors
         if (sseError.type === 'auth') {
+            if (!(this.sseOptions?.reconnectOnAuthError ?? true)) {
+                return;
+            }
+            const maxAuthReconnectAttempts = this.sseOptions?.maxAuthReconnectAttempts ?? 5;
+            if (this.sseAuthReconnectAttempts >= maxAuthReconnectAttempts) {
+                return;
+            }
+            this.sseAuthReconnectAttempts++;
+            this.scheduleReconnect();
             return;
         }
+        this.sseAuthReconnectAttempts = 0;
         this.scheduleReconnect();
     }
     /**
      * Schedules a reconnection attempt with exponential backoff
      */
     scheduleReconnect() {
-        if (!this.sseOptions?.autoReconnect) {
+        if (!this.shouldAttemptReconnect()) {
+            return;
+        }
+        const options = this.sseOptions;
+        if (!options) {
             return;
         }
-        if (this.sseOptions.maxReconnectAttempts !== undefined &&
-            this.sseReconnectAttempts >= this.sseOptions.maxReconnectAttempts) {
+        if (options.maxReconnectAttempts !== undefined &&
+            this.sseReconnectAttempts >= options.maxReconnectAttempts) {
             return;
         }
-        const initialDelay = this.sseOptions.initialReconnectDelay ?? 1000;
-        const maxDelay = this.sseOptions.maxReconnectDelay ?? 30000;
+        if (this.sseReconnectTimeout) {
+            return;
+        }
+        const initialDelay = options.initialReconnectDelay ?? 1000;
+        const maxDelay = options.maxReconnectDelay ?? 30000;
         // Exponential backoff with jitter
         const exponentialDelay = initialDelay * Math.pow(2, this.sseReconnectAttempts);
         const jitter = Math.random() * 1000;
         const delay = Math.min(exponentialDelay + jitter, maxDelay);
         this._sseConnectionState.next('reconnecting');
         this.sseReconnectAttempts++;
-        this.sseReconnectTimeout = setTimeout(async () => {
-            // Refresh token before reconnecting
-            try {
-                await this.refreshToken();
-            }
-            catch {
-                // Token refresh failed, will try again on next reconnect
+        this.sseReconnectTimeout = setTimeout(() => {
+            this.sseReconnectTimeout = undefined;
+            if (!this.shouldAttemptReconnect()) {
+                return;
             }
-            this._connectSSE();
+            void (async () => {
+                try {
+                    await this.refreshToken();
+                }
+                catch (error) {
+                    console.log('SSE reconnect: token refresh failed, scheduling another retry', error);
+                    this._sseError.next({
+                        type: 'auth',
+                        message: `Token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        timestamp: Date.now()
+                    });
+                    this.scheduleReconnect();
+                    return;
+                }
+                await this._connectSSE();
+            })();
         }, delay);
     }
 }

package/dist/interfaces.d.ts

@@ -130,6 +130,16 @@ export declare enum LibraryRole {
     share = "share",
     admin = "admin"
 }
+export interface UserMapping {
+    [key: string]: unknown;
+}
+export interface ServerLibrarySettings {
+    faceThreshold?: number;
+    ignoreGroups?: boolean;
+    preductionModel?: string;
+    mapProgress?: UserMapping[];
+    dataPath?: string;
+}
 export interface ILibrary {
     id?: string;
     name: string;
@@ -137,6 +147,7 @@ export interface ILibrary {
     source?: LibrarySources;
     roles?: LibraryRole[];
     crypt?: boolean;
+    settings: ServerLibrarySettings;
     hidden?: boolean;
     status?: string;
 }

package/dist/server.d.ts

@@ -11,7 +11,7 @@ export declare class ServerApi {
         timeout?: number;
     }): Promise<any>;
     addLibrary(library: Partial<ILibrary>): Promise<ILibrary>;
-    getSetting(key: string): Promise<string>;
+    updateLibrary(libraryId: string, library: Partial<ILibrary>): Promise<ILibrary>;
     getPlugins(): Promise<IPlugin[]>;
     getCredentials(): Promise<ICredential[]>;
     saveCredential(credential: ICredential): Promise<ICredential>;

package/dist/server.js

@@ -18,9 +18,9 @@ export class ServerApi {
         const res = await this.client.post('/libraries', library);
         return res.data;
     }
-    async getSetting(key) {
-        const res = await this.client.get(`/settings/${key}`);
-        return res.data.value;
+    async updateLibrary(libraryId, library) {
+        const res = await this.client.patch(`/libraries/${libraryId}`, library);
+        return res.data;
     }
     async getPlugins() {
         const res = await this.client.get('/plugins');

package/dist/sse-types.d.ts

@@ -12,6 +12,18 @@ export interface SSEConnectionOptions {
     initialReconnectDelay?: number;
     /** Maximum reconnect delay in ms (default: 30000) */
     maxReconnectDelay?: number;
+    /** Reconnect when tab becomes visible after being hidden for a while (default: true) */
+    reconnectOnPageVisible?: boolean;
+    /** Minimum hidden time before reconnecting on visible, in ms (default: 30000) */
+    reconnectVisibleAfterMs?: number;
+    /** Reconnect when browser comes back online (default: true) */
+    reconnectOnOnline?: boolean;
+    /** Reconnect on window focus when disconnected/error (default: true) */
+    reconnectOnFocus?: boolean;
+    /** Retry reconnection on auth (401) errors (default: true) */
+    reconnectOnAuthError?: boolean;
+    /** Maximum auth-error reconnect attempts before giving up (default: 5) */
+    maxAuthReconnectAttempts?: number;
 }
 export interface SSEConnectionError {
     type: 'network' | 'auth' | 'server' | 'parse';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redseat/api",
-    "version": "0.3.12",
+    "version": "0.3.14",
     "description": "TypeScript API client library for interacting with Redseat servers",
     "type": "module",
     "main": "./dist/index.js",

package/server.md

@@ -6,6 +6,7 @@ The `ServerApi` class provides server-level operations for managing libraries, s
 
 `ServerApi` handles operations that are not specific to a single library, such as:
 - Listing and creating libraries
+- Updating libraries
 - Getting current user information
 - Managing server settings
 - Listing plugins and credentials
@@ -66,6 +67,12 @@ Creates a new library.
   - `type`: Library type - `'photos'`, `'shows'`, `'movies'`, or `'iptv'` (required)
   - `source`: Optional source type
   - `crypt`: Optional boolean to enable encryption
+  - `settings`: Optional library settings object:
+    - `faceThreshold?: number`
+    - `ignoreGroups?: boolean`
+    - `preductionModel?: string` prediction model to use for tagging
+    - `mapProgress?: Record<string, any>[]` allow to map view progress from a user to another user
+    - `dataPath?: string` custom path to store library running data like thumnails, cache, portraits...
   - `hidden`: Optional boolean to hide library
 
 **Returns:** Promise resolving to the created `ILibrary` object with generated `id`
@@ -75,24 +82,33 @@ Creates a new library.
 const newLibrary = await serverApi.addLibrary({
     name: 'My Photos',
     type: 'photos',
-    crypt: true // Enable encryption
+    crypt: true, // Enable encryption
+    settings: {
+        faceThreshold: 0.7
+    }
 });
 console.log(`Created library with ID: ${newLibrary.id}`);
 ```
 
-### `getSetting(key: string): Promise<string>`
+### `updateLibrary(libraryId: string, library: Partial<ILibrary>): Promise<ILibrary>`
 
-Retrieves a server setting value by key.
+Updates an existing library.
 
 **Parameters:**
-- `key`: The setting key to retrieve
+- `libraryId`: The library ID to update
+- `library`: Partial library object containing fields to update (for example `name`, `source`, or `settings`)
 
-**Returns:** Promise resolving to the setting value as a string
+**Returns:** Promise resolving to the updated `ILibrary` object
 
 **Example:**
 ```typescript
-const maxUploadSize = await serverApi.getSetting('max_upload_size');
-console.log(`Max upload size: ${maxUploadSize}`);
+const updatedLibrary = await serverApi.updateLibrary('library-123', {
+    name: 'Renamed Library',
+    settings: {
+        faceThreshold: 0.8
+    }
+});
+console.log(`Updated library: ${updatedLibrary.name}`);
 ```
 
 ### `getPlugins(): Promise<any[]>`
@@ -509,6 +525,11 @@ const newLibrary = await serverApi.addLibrary({
     crypt: true
 });
 
+// Update the library settings
+const updatedLibrary = await serverApi.updateLibrary(newLibrary.id!, {
+    name: 'Encrypted Family Photos'
+});
+
 // Get server settings
 const maxUpload = await serverApi.getSetting('max_upload_size');
 console.log(`Max upload size: ${maxUpload}`);
@@ -535,4 +556,3 @@ try {
 - [RedseatClient Documentation](client.md) - HTTP client used by ServerApi
 - [LibraryApi Documentation](libraries.md) - Library-specific operations
 - [README](README.md) - Package overview
-