@redseat/api 0.3.7 → 0.3.11

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>;
@@ -47,6 +47,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: {...}} -> {...})

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 => {
@@ -57,6 +63,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;

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,31 @@ 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;
+}

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 } from './interfaces.js';
 export type ElementAction = 'Added' | 'Updated' | 'Deleted';
 export type SSEConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
 export interface SSEConnectionOptions {
@@ -146,6 +146,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 +176,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.11",
     "description": "TypeScript API client library for interacting with Redseat servers",
     "type": "module",
     "main": "./dist/index.js",