@redseat/api 0.3.7 → 0.3.12

package/dist/client.d.ts

@@ -2,7 +2,7 @@ import { Method, AxiosRequestConfig } from 'axios';
 import { Observable } from 'rxjs';
 import { IToken } from './auth.js';
 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 } from './sse-types.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>;
@@ -20,6 +20,8 @@ export declare class RedseatClient {
     private localServerUrl?;
     private tokenData?;
     private tokenRefreshPromise?;
+    private localDetectionAbortController?;
+    private disposed;
     private sseAbortController?;
     private sseReconnectTimeout?;
     private sseReconnectAttempts;
@@ -47,6 +49,7 @@ export declare class RedseatClient {
     readonly playersList$: Observable<SSEPlayersListEvent>;
     readonly watched$: Observable<SSEWatchedEvent>;
     readonly unwatched$: Observable<SSEUnwatchedEvent>;
+    readonly requestProcessing$: Observable<SSERequestProcessingEvent>;
     /**
      * Creates a typed observable for a specific SSE event type.
      * Unwraps the nested data structure from the server (e.g., {uploadProgress: {...}} -> {...})
@@ -102,7 +105,7 @@ export declare class RedseatClient {
      */
     disconnectSSE(): void;
     /**
-     * Disposes of all SSE resources and completes observables.
+     * Disposes of all resources and completes observables.
      * Call this when the client is no longer needed.
      */
     dispose(): void;

package/dist/client.js

@@ -17,6 +17,12 @@ export class RedseatClient {
             'library-status': 'libraryStatus',
             'backups-files': 'backupsFiles',
             'players-list': 'Players',
+            'episodes': 'episodes',
+            'series': 'series',
+            'movies': 'movies',
+            'people': 'people',
+            'tags': 'tags',
+            'request_processing': 'requestProcessing',
         };
         const wrapperKey = wrapperMap[eventName];
         return this._sseEvents.pipe(filter((event) => event.event === eventName), map(event => {
@@ -30,6 +36,7 @@ export class RedseatClient {
         }));
     }
     constructor(options) {
+        this.disposed = false;
         this.sseReconnectAttempts = 0;
         // RxJS subjects for SSE
         this._sseConnectionState = new BehaviorSubject('disconnected');
@@ -57,6 +64,7 @@ export class RedseatClient {
         this.playersList$ = this.createEventStream('players-list');
         this.watched$ = this.createEventStream('watched');
         this.unwatched$ = this.createEventStream('unwatched');
+        this.requestProcessing$ = this.createEventStream('request_processing');
         this.server = options.server;
         this.redseatUrl = options.redseatUrl;
         this.getIdToken = options.getIdToken;
@@ -65,16 +73,19 @@ export class RedseatClient {
         this.baseUrl = this.getRegularServerUrl();
         this.axios = axios.create({
             baseURL: this.baseUrl,
-            timeout: options.timeout ?? 0
+            timeout: options.timeout ?? 30000 // 30 second default
         });
         // Detect local URL asynchronously and update axios instance
-        this.detectLocalUrl().then((url) => {
+        this.localDetectionAbortController = new AbortController();
+        this.detectLocalUrl(this.localDetectionAbortController.signal).then((url) => {
+            if (this.disposed)
+                return; // Don't update if disposed
             if (url !== this.baseUrl) {
                 this.baseUrl = url;
                 this.axios.defaults.baseURL = url;
             }
         }).catch(() => {
-            // If detection fails, use regular URL (already set)
+            // If detection fails or aborted, use regular URL (already set)
         });
         // Request interceptor: check token expiration and refresh if needed
         this.axios.interceptors.request.use(async (config) => {
@@ -110,7 +121,7 @@ export class RedseatClient {
         }
         return `https://${base}`;
     }
-    async detectLocalUrl() {
+    async detectLocalUrl(signal) {
         let localBase = `local.${this.server.url}`;
         if (this.server.port) {
             localBase = `${localBase}:${this.server.port}`;
@@ -120,7 +131,8 @@ export class RedseatClient {
             console.log('trying local server url', localUrl);
             const response = await axios.get(`${localUrl}/ping`, {
                 timeout: 200,
-                headers: { "Referrer-Policy": 'origin-when-cross-origin' }
+                headers: { "Referrer-Policy": 'origin-when-cross-origin' },
+                signal
             });
             if (response.status === 200) {
                 console.log('local server detected');
@@ -301,10 +313,13 @@ export class RedseatClient {
         this._sseConnectionState.next('disconnected');
     }
     /**
-     * Disposes of all SSE resources and completes observables.
+     * Disposes of all resources and completes observables.
      * Call this when the client is no longer needed.
      */
     dispose() {
+        this.disposed = true;
+        this.localDetectionAbortController?.abort();
+        this.localDetectionAbortController = undefined;
         this.disconnectSSE();
         this._sseConnectionState.complete();
         this._sseError.complete();

package/dist/interfaces.d.ts

@@ -731,6 +731,8 @@ export interface RsRequest {
     size?: number;
     filename?: string;
     status: RsRequestStatus;
+    pluginName?: string;
+    pluginId?: string;
     permanent: boolean;
     instant?: boolean;
     jsonBody?: any;
@@ -768,3 +770,89 @@ export interface RsGroupDownload {
     groupMime?: string;
     requests: RsRequest[];
 }
+/**
+ * Request processing status from plugin-based download/processing.
+ * Tracks progress of downloads, file processing, etc.
+ */
+export interface IRsRequestProcessing {
+    /** Internal nanoid */
+    id: string;
+    /** Plugin's processing ID */
+    processingId: string;
+    /** Plugin handling the request */
+    pluginId: string;
+    /** Progress 0-100 */
+    progress: number;
+    /** Status: "pending" | "processing" | "paused" | "finished" | "error" */
+    status: string;
+    /** Error message if status is "error" */
+    error?: string;
+    /** UTC timestamp (ms) for estimated completion */
+    eta?: number;
+    /** Reference to media being processed */
+    mediaRef?: string;
+    /** The original request */
+    originalRequest?: RsRequest;
+    /** Last modified timestamp */
+    modified: number;
+    /** Creation timestamp */
+    added: number;
+}
+export declare enum VideoOverlayPosition {
+    topLeft = "topLeft",
+    topRight = "topRight",
+    topCenter = "topCenter",
+    bottomLeft = "bottomLeft",
+    bottomRight = "bottomRight",
+    bottomCenter = "bottomCenter",
+    Center = "center"
+}
+export declare enum VideoOverlayType {
+    watermark = "watermark",
+    file = "file"
+}
+export interface VideoOverlay {
+    type: VideoOverlayType;
+    path: string;
+    position?: VideoOverlayPosition;
+    margin?: number;
+    ratio: number;
+    opacity: number;
+}
+export interface VideoTextOverlay {
+    text: string;
+    fontColor: string;
+    font?: string;
+    position: VideoOverlayPosition;
+    marginHorizontal?: number;
+    marginVertical?: number;
+    fontSize: number;
+    opacity?: number;
+    shadowColor: string;
+    shadowOpacity?: number;
+    start?: number;
+    end?: number;
+}
+export interface VideoConvertInterval {
+    start: number;
+    duration: number;
+    /** Defaults to current input */
+    input?: string;
+}
+export interface VideoConvertRequest {
+    id: string;
+    format: string;
+    codec?: string;
+    crf?: number;
+    noAudio?: boolean;
+    width?: string;
+    height?: string;
+    framerate?: number;
+    cropWidth?: number;
+    cropHeight?: number;
+    aspectRatio?: string;
+    aspectRatioAlignment?: 'center' | 'left' | 'right';
+    overlay?: VideoOverlay;
+    texts?: VideoTextOverlay[];
+    intervals?: VideoConvertInterval[];
+}

package/dist/interfaces.js

@@ -88,3 +88,19 @@ export var RsRequestMethod;
     RsRequestMethod["Delete"] = "delete";
     RsRequestMethod["Head"] = "head";
 })(RsRequestMethod || (RsRequestMethod = {}));
+// ========== Video Convert Types ==========
+export var VideoOverlayPosition;
+(function (VideoOverlayPosition) {
+    VideoOverlayPosition["topLeft"] = "topLeft";
+    VideoOverlayPosition["topRight"] = "topRight";
+    VideoOverlayPosition["topCenter"] = "topCenter";
+    VideoOverlayPosition["bottomLeft"] = "bottomLeft";
+    VideoOverlayPosition["bottomRight"] = "bottomRight";
+    VideoOverlayPosition["bottomCenter"] = "bottomCenter";
+    VideoOverlayPosition["Center"] = "center";
+})(VideoOverlayPosition || (VideoOverlayPosition = {}));
+export var VideoOverlayType;
+(function (VideoOverlayType) {
+    VideoOverlayType["watermark"] = "watermark";
+    VideoOverlayType["file"] = "file";
+})(VideoOverlayType || (VideoOverlayType = {}));

package/dist/library.d.ts

@@ -1,6 +1,7 @@
 import { Observable } from 'rxjs';
-import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched } from './interfaces.js';
-import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent } from './sse-types.js';
+import type { AxiosResponse } from 'axios';
+import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched, IRsRequestProcessing } from './interfaces.js';
+import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSERequestProcessingEvent } from './sse-types.js';
 import { EncryptFileOptions, EncryptedFile } from './encryption.js';
 export interface MediaForUpdate {
     name?: string;
@@ -87,6 +88,7 @@ export interface LibraryHttpClient {
     readonly libraryStatus$?: Observable<SSELibraryStatusEvent>;
     readonly mediaRating$?: Observable<SSEMediaRatingEvent>;
     readonly mediaProgress$?: Observable<SSEMediaProgressEvent>;
+    readonly requestProcessing$?: Observable<SSERequestProcessingEvent>;
 }
 export declare class LibraryApi {
     private client;
@@ -106,6 +108,7 @@ export declare class LibraryApi {
     readonly libraryStatus$: Observable<SSELibraryStatusEvent>;
     readonly mediaRating$: Observable<SSEMediaRatingEvent>;
     readonly mediaProgress$: Observable<SSEMediaProgressEvent>;
+    readonly requestProcessing$: Observable<SSERequestProcessingEvent>;
     constructor(client: LibraryHttpClient, libraryId: string, library: ILibrary);
     /**
      * Creates a library-filtered stream from a client stream.
@@ -253,6 +256,43 @@ export declare class LibraryApi {
     checkRequestInstant(request: RsRequest): Promise<{
         instant: boolean;
     }>;
+    /**
+     * Process an unprocessed RsRequest and return the processed result.
+     * Takes a raw request and runs it through the server's plugin processing pipeline.
+     * @param request - The unprocessed request to process
+     * @returns The processed request with updated status and metadata
+     */
+    processRequest(request: RsRequest): Promise<RsRequest>;
+    /**
+     * Process a request and return the raw HTTP stream response.
+     * Use this to stream content directly without processing the full response.
+     * @param request - The request to process and stream
+     * @returns Raw axios response with stream data - use response.data for the stream
+     */
+    processRequestStream(request: RsRequest): Promise<AxiosResponse>;
+    /**
+     * Add a request to the processing queue.
+     * @param request - The request to add for processing
+     * @param mediaRef - Optional media reference to associate with the processing
+     * @returns The created request processing entry
+     */
+    addRequest(request: RsRequest, mediaRef?: string): Promise<IRsRequestProcessing>;
+    /**
+     * List all active request processings for this library.
+     * @returns Array of request processing entries
+     */
+    listRequestProcessing(): Promise<IRsRequestProcessing[]>;
+    /**
+     * Pause a request processing task.
+     * @param processingId - The ID of the processing task to pause
+     * @returns The updated request processing entry with status "paused"
+     */
+    pauseRequestProcessing(processingId: string): Promise<IRsRequestProcessing>;
+    /**
+     * Delete/remove a request processing task.
+     * @param processingId - The ID of the processing task to delete
+     */
+    deleteRequestProcessing(processingId: string): Promise<void>;
     /**
      * Get a share token for a request URL.
      * The token can be used to stream/download the resource without authentication.

package/dist/library.js

@@ -19,6 +19,7 @@ export class LibraryApi {
         this.libraryStatus$ = this.createLibraryFilteredStream(client.libraryStatus$);
         this.mediaRating$ = this.createLibraryFilteredStream(client.mediaRating$);
         this.mediaProgress$ = this.createLibraryFilteredStream(client.mediaProgress$);
+        this.requestProcessing$ = this.createLibraryFilteredStream(client.requestProcessing$);
     }
     /**
      * Creates a library-filtered stream from a client stream.
@@ -525,6 +526,59 @@ export class LibraryApi {
         const res = await this.client.post(this.getUrl('/plugins/requests/check-instant'), request);
         return res.data;
     }
+    /**
+     * Process an unprocessed RsRequest and return the processed result.
+     * Takes a raw request and runs it through the server's plugin processing pipeline.
+     * @param request - The unprocessed request to process
+     * @returns The processed request with updated status and metadata
+     */
+    async processRequest(request) {
+        const res = await this.client.post(this.getUrl('/plugins/requests/process'), request);
+        return res.data;
+    }
+    /**
+     * Process a request and return the raw HTTP stream response.
+     * Use this to stream content directly without processing the full response.
+     * @param request - The request to process and stream
+     * @returns Raw axios response with stream data - use response.data for the stream
+     */
+    async processRequestStream(request) {
+        return this.client.post(this.getUrl('/plugins/requests/process/stream'), request, { responseType: 'stream' });
+    }
+    /**
+     * Add a request to the processing queue.
+     * @param request - The request to add for processing
+     * @param mediaRef - Optional media reference to associate with the processing
+     * @returns The created request processing entry
+     */
+    async addRequest(request, mediaRef) {
+        const res = await this.client.post(this.getUrl('/plugins/requests/add'), { request, mediaRef });
+        return res.data;
+    }
+    /**
+     * List all active request processings for this library.
+     * @returns Array of request processing entries
+     */
+    async listRequestProcessing() {
+        const res = await this.client.get(this.getUrl('/plugins/requests/processing'));
+        return res.data;
+    }
+    /**
+     * Pause a request processing task.
+     * @param processingId - The ID of the processing task to pause
+     * @returns The updated request processing entry with status "paused"
+     */
+    async pauseRequestProcessing(processingId) {
+        const res = await this.client.post(this.getUrl(`/plugins/requests/processing/${processingId}/pause`));
+        return res.data;
+    }
+    /**
+     * Delete/remove a request processing task.
+     * @param processingId - The ID of the processing task to delete
+     */
+    async deleteRequestProcessing(processingId) {
+        await this.client.delete(this.getUrl(`/plugins/requests/processing/${processingId}`));
+    }
     /**
      * Get a share token for a request URL.
      * The token can be used to stream/download the resource without authentication.

package/dist/sse-types.d.ts

@@ -1,4 +1,4 @@
-import { ILibrary, IFile, IEpisode, ISerie, IMovie, IPerson, ITag, IBackup, IWatched, IUnwatched } from './interfaces.js';
+import { ILibrary, IFile, IEpisode, ISerie, IMovie, IPerson, ITag, IBackup, IWatched, IUnwatched, IRsRequestProcessing, VideoConvertRequest } from './interfaces.js';
 export type ElementAction = 'Added' | 'Updated' | 'Deleted';
 export type SSEConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
 export interface SSEConnectionOptions {
@@ -50,12 +50,20 @@ export interface SSEUploadProgressEvent {
     progress: RsProgress;
     remainingSecondes?: number;
 }
+export type RsVideoTranscodeStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'canceled';
+export interface ConvertProgress {
+    id: string;
+    filename: string;
+    convertedId: string | null;
+    done: boolean;
+    percent: number;
+    status: RsVideoTranscodeStatus;
+    estimatedRemainingSeconds: number | null;
+    request: VideoConvertRequest | null;
+}
 export interface SSEConvertProgressEvent {
     library: string;
-    mediaId: string;
-    progress: number;
-    status: string;
-    message?: string;
+    progress: ConvertProgress;
 }
 export interface SSEEpisodesEvent {
     library: string;
@@ -146,6 +154,18 @@ export type SSEWatchedEvent = IWatched;
  * This is a user-scoped event - not library-scoped.
  */
 export type SSEUnwatchedEvent = IUnwatched;
+/**
+ * SSE event for request processing status updates.
+ * Tracks plugin-based request processing (downloads, file processing, etc.).
+ * This is a library-scoped event.
+ */
+export interface SSERequestProcessingEvent {
+    library: string;
+    processings: {
+        action: ElementAction;
+        processing: IRsRequestProcessing;
+    }[];
+}
 export interface SSEEventMap {
     'library': SSELibraryEvent;
     'library-status': SSELibraryStatusEvent;
@@ -164,6 +184,7 @@ export interface SSEEventMap {
     'players-list': SSEPlayersListEvent;
     'watched': SSEWatchedEvent;
     'unwatched': SSEUnwatchedEvent;
+    'request_processing': SSERequestProcessingEvent;
 }
 export type SSEEventName = keyof SSEEventMap;
 export interface SSEEvent<T extends SSEEventName = SSEEventName> {

package/libraries.md

@@ -1969,6 +1969,158 @@ await libraryApi.clusterFaces('person-id');
 
 ---
 
+## Request Processing
+
+### `processRequest(request: RsRequest): Promise<RsRequest>`
+
+Process an unprocessed RsRequest and return the processed result.
+Takes a raw request and runs it through the server's plugin processing pipeline.
+
+**Parameters:**
+
+- `request`: The unprocessed request to process
+
+**Returns:** Promise resolving to the processed request with updated status and metadata
+
+**Example:**
+
+```typescript
+import { RsRequestStatus, RsRequestMethod } from '@redseat/api';
+
+const unprocessedRequest: RsRequest = {
+	url: 'https://example.com/video.mp4',
+	method: RsRequestMethod.Get,
+	status: RsRequestStatus.Unprocessed,
+	permanent: false,
+	ignoreOriginDuplicate: false
+};
+const processed = await libraryApi.processRequest(unprocessedRequest);
+console.log(processed.status); // RsRequestStatus.Processed
+```
+
+### `processRequestStream(request: RsRequest): Promise<AxiosResponse>`
+
+Process a request and return the raw HTTP stream response for direct streaming.
+
+**Parameters:**
+
+- `request`: The request to process and stream
+
+**Returns:** Raw axios response - use `response.data` for the stream
+
+**Example:**
+
+```typescript
+const request: RsRequest = {
+	url: 'https://example.com/video.mp4',
+	method: RsRequestMethod.Get,
+	status: RsRequestStatus.Processed,
+	permanent: false,
+	ignoreOriginDuplicate: false
+};
+const response = await libraryApi.processRequestStream(request);
+// response.data is the stream that can be piped directly
+```
+
+### `addRequest(request: RsRequest, mediaRef?: string): Promise<IRsRequestProcessing>`
+
+Add a request to the processing queue for background download/processing.
+
+**Parameters:**
+
+- `request`: The request to add for processing
+- `mediaRef`: Optional media reference to associate with the processing
+
+**Returns:** Promise resolving to the created `IRsRequestProcessing` entry
+
+**Example:**
+
+```typescript
+import { RsRequestStatus, RsRequestMethod } from '@redseat/api';
+
+const request: RsRequest = {
+	url: 'https://example.com/large-video.mp4',
+	method: RsRequestMethod.Get,
+	status: RsRequestStatus.Unprocessed,
+	permanent: false,
+	ignoreOriginDuplicate: false
+};
+
+// Add to processing queue
+const processing = await libraryApi.addRequest(request);
+console.log(processing.id); // Processing ID
+console.log(processing.status); // "pending" | "processing" | "paused" | "finished" | "error"
+console.log(processing.progress); // 0-100
+
+// Associate with existing media
+const processingWithMedia = await libraryApi.addRequest(request, 'media-id');
+```
+
+### `listRequestProcessing(): Promise<IRsRequestProcessing[]>`
+
+List all active request processings for this library.
+
+**Returns:** Promise resolving to an array of `IRsRequestProcessing` entries
+
+**Example:**
+
+```typescript
+const processings = await libraryApi.listRequestProcessing();
+for (const p of processings) {
+	console.log(`${p.id}: ${p.status} (${p.progress}%)`);
+	if (p.error) {
+		console.log(`  Error: ${p.error}`);
+	}
+	if (p.mediaRef) {
+		console.log(`  Media: ${p.mediaRef}`);
+	}
+}
+```
+
+### `pauseRequestProcessing(processingId: string): Promise<IRsRequestProcessing>`
+
+Pause a request processing task. This stops the download/processing temporarily.
+
+**Parameters:**
+
+- `processingId`: The ID of the processing task to pause
+
+**Returns:** Promise resolving to the updated `IRsRequestProcessing` entry with status "paused"
+
+**Example:**
+
+```typescript
+const processings = await libraryApi.listRequestProcessing();
+const activeProcessing = processings.find(p => p.status === 'processing');
+
+if (activeProcessing) {
+	const paused = await libraryApi.pauseRequestProcessing(activeProcessing.id);
+	console.log(`Paused: ${paused.id}, status: ${paused.status}`); // status: "paused"
+}
+```
+
+### `deleteRequestProcessing(processingId: string): Promise<void>`
+
+Delete/remove a request processing task from the queue. This cancels and removes the processing entry.
+
+**Parameters:**
+
+- `processingId`: The ID of the processing task to delete
+
+**Example:**
+
+```typescript
+const processings = await libraryApi.listRequestProcessing();
+const processingToRemove = processings.find(p => p.status === 'error');
+
+if (processingToRemove) {
+	await libraryApi.deleteRequestProcessing(processingToRemove.id);
+	console.log(`Removed processing: ${processingToRemove.id}`);
+}
+```
+
+---
+
 ## Encryption
 
 These methods are convenience wrappers around the encryption module. For detailed encryption documentation, see [encryption.md](encryption.md).

package/package.json

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