@redseat/api 0.5.0 → 0.6.1

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, SSEBooksEvent, SSEPeopleEvent, SSETagsEvent, SSEBackupsEvent, SSEBackupFilesEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSEPlayersListEvent, SSEWatchedEvent, SSEUnwatchedEvent, SSERequestProcessingEvent } from './sse-types.js';
+import { SSEConnectionState, SSEConnectionOptions, SSEConnectionError, SSELibraryEvent, SSELibraryStatusEvent, SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEBooksEvent, SSEPeopleEvent, SSETagsEvent, SSEBackupsEvent, SSEBackupFilesEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSEPlayersListEvent, SSEWatchedEvent, SSEUnwatchedEvent, SSERequestProcessingEvent, SSEChannelsEvent } from './sse-types.js';
 export interface ClientOptions {
     server: IServer;
     getIdToken: (forceRefresh?: boolean) => Promise<string>;
@@ -25,6 +25,7 @@ export declare class RedseatClient {
     private sseAbortController?;
     private sseReconnectTimeout?;
     private sseActivityTimeout?;
+    private sseHealthCheckInterval?;
     private sseReconnectAttempts;
     private sseAuthReconnectAttempts;
     private sseOptions?;
@@ -33,6 +34,7 @@ export declare class RedseatClient {
     private sseLifecycleRegistered;
     private sseHiddenAt?;
     private readonly SSE_ACTIVITY_TIMEOUT;
+    private readonly SSE_HEALTH_CHECK_INTERVAL;
     private readonly _sseConnectionState;
     private readonly _sseError;
     private readonly _sseEvents;
@@ -58,6 +60,7 @@ export declare class RedseatClient {
     readonly watched$: Observable<SSEWatchedEvent>;
     readonly unwatched$: Observable<SSEUnwatchedEvent>;
     readonly requestProcessing$: Observable<SSERequestProcessingEvent>;
+    readonly channels$: Observable<SSEChannelsEvent>;
     /**
      * Creates a typed observable for a specific SSE event type.
      * Unwraps the nested data structure from the server (e.g., {uploadProgress: {...}} -> {...})
@@ -92,6 +95,11 @@ export declare class RedseatClient {
      * @throws Error if not authenticated
      */
     getAuthToken(): string;
+    /**
+     * Ensures the token is valid (refreshing if needed) and returns it.
+     * Use this when you need a guaranteed-fresh token outside of axios interceptors.
+     */
+    getValidAuthToken(): Promise<string>;
     /**
      * Fetches all servers for the authenticated user.
      * Returns IServerPrivate for owned servers, IServer for shared servers.
@@ -148,6 +156,16 @@ export declare class RedseatClient {
      * Clears the activity timeout timer.
      */
     private clearActivityTimeout;
+    /**
+     * Starts a periodic health check that detects when the reconnect chain
+     * has silently died (no pending reconnect, not connecting, not connected)
+     * and forces a new reconnection attempt.
+     */
+    private startSSEHealthCheck;
+    /**
+     * Stops the periodic health check.
+     */
+    private stopSSEHealthCheck;
     /**
      * Processes the SSE stream and emits events
      */

package/dist/client.js

@@ -25,6 +25,7 @@ export class RedseatClient {
             'people': 'people',
             'tags': 'tags',
             'request_processing': 'requestProcessing',
+            'channels': 'channels',
         };
         const wrapperKey = wrapperMap[eventName];
         return this._sseEvents.pipe(filter((event) => event.event === eventName), map(event => {
@@ -45,6 +46,7 @@ export class RedseatClient {
         this.sseIsConnecting = false;
         this.sseLifecycleRegistered = false;
         this.SSE_ACTIVITY_TIMEOUT = 90000; // 90 seconds - reconnect if no data received
+        this.SSE_HEALTH_CHECK_INTERVAL = 60000; // 60 seconds - periodic connection check
         // RxJS subjects for SSE
         this._sseConnectionState = new BehaviorSubject('disconnected');
         this._sseError = new Subject();
@@ -73,6 +75,7 @@ export class RedseatClient {
         this.watched$ = this.createEventStream('watched');
         this.unwatched$ = this.createEventStream('unwatched');
         this.requestProcessing$ = this.createEventStream('request_processing');
+        this.channels$ = this.createEventStream('channels');
         // ==================== SSE Methods ====================
         this.onDocumentVisibilityChange = () => {
             if (!this.shouldAttemptReconnect() || typeof document === 'undefined') {
@@ -317,6 +320,14 @@ export class RedseatClient {
         }
         return this.tokenData.token;
     }
+    /**
+     * Ensures the token is valid (refreshing if needed) and returns it.
+     * Use this when you need a guaranteed-fresh token outside of axios interceptors.
+     */
+    async getValidAuthToken() {
+        await this.ensureValidToken();
+        return this.getAuthToken();
+    }
     /**
      * Fetches all servers for the authenticated user.
      * Returns IServerPrivate for owned servers, IServer for shared servers.
@@ -383,13 +394,21 @@ export class RedseatClient {
             return;
         }
         this.clearSSEReconnectTimeout();
+        const wasConnecting = this.sseIsConnecting;
         if (this.sseAbortController) {
             this.sseAbortController.abort();
             this.sseAbortController = undefined;
         }
         this.sseReconnectAttempts = 0;
         this._sseConnectionState.next('reconnecting');
-        void this._connectSSE();
+        if (wasConnecting) {
+            // _connectSSE is mid-fetch; aborting it will make it catch AbortError and return.
+            // Schedule a reconnect so a new attempt happens after it finishes.
+            this.scheduleReconnect();
+        }
+        else {
+            void this._connectSSE();
+        }
     }
     /**
      * Connects to the server's SSE endpoint for real-time updates.
@@ -415,6 +434,7 @@ export class RedseatClient {
         this.sseAuthReconnectAttempts = 0;
         this.sseShouldReconnect = true;
         this.registerSSELifecycleListeners();
+        this.startSSEHealthCheck();
         await this._connectSSE();
     }
     /**
@@ -426,6 +446,7 @@ export class RedseatClient {
         this.sseAuthReconnectAttempts = 0;
         this.clearSSEReconnectTimeout();
         this.clearActivityTimeout();
+        this.stopSSEHealthCheck();
         if (this.sseAbortController) {
             this.sseAbortController.abort();
             this.sseAbortController = undefined;
@@ -528,11 +549,15 @@ export class RedseatClient {
             });
         }
         catch (error) {
+            this.sseAbortController = undefined;
             if (error instanceof Error && error.name === 'AbortError') {
-                // Intentionally disconnected
+                // Aborted — if we should still reconnect and no reconnect is pending, schedule one.
+                // This handles the case where forceReconnectSSE aborted us mid-fetch.
+                if (this.shouldAttemptReconnect() && !this.sseReconnectTimeout) {
+                    this.scheduleReconnect();
+                }
                 return;
             }
-            this.sseAbortController = undefined;
             this.handleSSEError(error);
         }
         finally {
@@ -584,6 +609,37 @@ export class RedseatClient {
             this.sseActivityTimeout = undefined;
         }
     }
+    /**
+     * Starts a periodic health check that detects when the reconnect chain
+     * has silently died (no pending reconnect, not connecting, not connected)
+     * and forces a new reconnection attempt.
+     */
+    startSSEHealthCheck() {
+        this.stopSSEHealthCheck();
+        this.sseHealthCheckInterval = setInterval(() => {
+            if (this.disposed || !this.sseShouldReconnect) {
+                this.stopSSEHealthCheck();
+                return;
+            }
+            const state = this.sseConnectionState;
+            if (state !== 'connected' &&
+                state !== 'connecting' &&
+                !this.sseReconnectTimeout &&
+                !this.sseIsConnecting) {
+                console.log('SSE health check: connection dead with no pending reconnect, forcing reconnect');
+                this.forceReconnectSSE();
+            }
+        }, this.SSE_HEALTH_CHECK_INTERVAL);
+    }
+    /**
+     * Stops the periodic health check.
+     */
+    stopSSEHealthCheck() {
+        if (this.sseHealthCheckInterval) {
+            clearInterval(this.sseHealthCheckInterval);
+            this.sseHealthCheckInterval = undefined;
+        }
+    }
     /**
      * Processes the SSE stream and emits events
      */
@@ -638,6 +694,10 @@ export class RedseatClient {
             throw error;
         }
         finally {
+            // Ensure the underlying connection is fully closed before releasing
+            if (this.sseAbortController && !this.sseAbortController.signal.aborted) {
+                this.sseAbortController.abort();
+            }
             this.sseAbortController = undefined;
             reader.releaseLock();
         }
@@ -713,15 +773,29 @@ export class RedseatClient {
                 }
                 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()
-                    });
+                    try {
+                        this._sseError.next({
+                            type: 'auth',
+                            message: `Token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            timestamp: Date.now()
+                        });
+                    }
+                    catch { /* prevent subscriber errors from breaking the chain */ }
                     this.scheduleReconnect();
                     return;
                 }
-                await this._connectSSE();
+                try {
+                    await this._connectSSE();
+                }
+                catch (error) {
+                    // Safety net: _connectSSE has its own try/catch, but if anything
+                    // escapes (e.g. a subscriber throwing in RxJS next()), don't let
+                    // it silently kill the reconnect chain.
+                    console.error('SSE reconnect: unexpected error in _connectSSE', error);
+                    if (this.shouldAttemptReconnect()) {
+                        this.scheduleReconnect();
+                    }
+                }
             })();
         }, delay);
     }

package/dist/interfaces.d.ts

@@ -194,6 +194,7 @@ export interface ServerLibrarySettings {
     preductionModel?: string;
     mapProgress?: UserMapping[];
     dataPath?: string;
+    epgUrl?: string;
 }
 export interface ServerLibraryForUpdate {
     name?: string;
@@ -490,11 +491,17 @@ export type SearchResult<K extends string, T> = SearchStreamResult<K, T>;
 export type BookSearchResult = SearchResult<'book', IBook>;
 export type MovieSearchResult = SearchResult<'movie', IMovie>;
 export type SerieSearchResult = SearchResult<'serie', ISerie>;
+export type PersonSearchResult = SearchResult<'person', IPerson>;
 export type BookSearchStreamResult = SearchStreamResult<'book', IBook>;
 export type MovieSearchStreamResult = SearchStreamResult<'movie', IMovie>;
 export type SerieSearchStreamResult = SearchStreamResult<'serie', ISerie>;
+export type PersonSearchStreamResult = SearchStreamResult<'person', IPerson>;
 export type LookupSearchStreamResult = SearchStreamResult<'book' | 'movie' | 'serie', IBook | IMovie | ISerie>;
 export type RsLookupMatchType = 'exactId' | 'exactText';
+export interface SourceSearchStreamResult {
+    request: RsRequest;
+    matchType?: RsLookupMatchType;
+}
 export interface SseSearchStreamEvent<T> {
     sourceId: string;
     sourceName: string;
@@ -509,17 +516,35 @@ export interface SearchStreamCallbacks<T> {
 export interface IChannel {
     id: string;
     name: string;
-    series: string[];
-    lang?: string;
-    versions: IChannelVersion[];
-    type?: FileTypes;
+    tvgId?: string;
+    logo?: string;
+    tags?: string[];
+    channelNumber?: number;
+    modified?: number;
+    added?: number;
+    variants?: IChannelVariant[];
 }
-export interface IChannelVersion {
+export interface IChannelVariant {
     id: string;
-    name: string;
-    source: string;
+    channelRef: string;
     quality?: string;
-    description?: string;
+    streamUrl: string;
+    modified?: number;
+    added?: number;
+}
+export interface M3uImportResult {
+    channelsAdded: number;
+    channelsUpdated: number;
+    channelsRemoved: number;
+    moviesAdded: number;
+    seriesAdded: number;
+    episodesAdded: number;
+    groupsCreated: number;
+    totalParsed: number;
+}
+export interface ChannelQuery {
+    tag?: string;
+    name?: string;
 }
 export interface UnassignedFace {
     id: string;
@@ -576,9 +601,6 @@ export interface MergePeopleResponse {
 export interface ClusterFacesResponse {
     clusters: number;
 }
-export interface IChannelUpdate {
-    [key: string]: any;
-}
 export declare enum PluginAuthType {
     OAUTH = "oauth",
     URL = "url",
@@ -834,6 +856,8 @@ export interface HistoryQuery {
     id?: string;
     /** Pagination key for next page */
     pageKey?: number;
+    /** Include soft-deleted entries (date=0) for sync purposes */
+    include_deleted?: boolean;
 }
 export type MovieSort = 'modified' | 'added' | 'created' | 'name' | 'digitalairdate';
 export interface DeletedQuery {

package/dist/library.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import type { AxiosResponse } from 'axios';
-import { IFile, ITag, IPerson, ISerie, IMovie, IBook, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, DeletedQuery, RsDeleted, MovieSort, BookSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched, IRsRequestProcessing, BookSearchStreamResult, MovieSearchStreamResult, SerieSearchStreamResult, LookupSearchStreamResult, BookSearchResult, MovieSearchResult, SerieSearchResult, ItemWithRelations, SearchStreamCallbacks, MediaForUpdate, IChannelUpdate } from './interfaces.js';
-import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEBooksEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSERequestProcessingEvent } from './sse-types.js';
+import { IFile, ITag, IPerson, ISerie, IMovie, IBook, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, DeletedQuery, RsDeleted, MovieSort, BookSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched, IRsRequestProcessing, BookSearchStreamResult, MovieSearchStreamResult, SerieSearchStreamResult, PersonSearchStreamResult, LookupSearchStreamResult, SourceSearchStreamResult, BookSearchResult, MovieSearchResult, SerieSearchResult, ItemWithRelations, SearchStreamCallbacks, MediaForUpdate, type IChannel, type M3uImportResult, type ChannelQuery } from './interfaces.js';
+import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEBooksEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSERequestProcessingEvent, SSEChannelsEvent } from './sse-types.js';
 import { EncryptFileOptions, EncryptedFile } from './encryption.js';
 export interface LibraryHttpClient {
     get<T = unknown>(url: string, config?: any): Promise<{
@@ -37,6 +37,7 @@ export interface LibraryHttpClient {
     readonly mediaRating$?: Observable<SSEMediaRatingEvent>;
     readonly mediaProgress$?: Observable<SSEMediaProgressEvent>;
     readonly requestProcessing$?: Observable<SSERequestProcessingEvent>;
+    readonly channels$?: Observable<SSEChannelsEvent>;
 }
 export interface UploadMediaMultipartOptions {
     file: Blob;
@@ -64,6 +65,7 @@ export declare class LibraryApi {
     readonly mediaRating$: Observable<SSEMediaRatingEvent>;
     readonly mediaProgress$: Observable<SSEMediaProgressEvent>;
     readonly requestProcessing$: Observable<SSERequestProcessingEvent>;
+    readonly channels$: Observable<SSEChannelsEvent>;
     constructor(client: LibraryHttpClient, libraryId: string, library: ILibrary);
     /**
      * Creates a library-filtered stream from a client stream.
@@ -145,6 +147,7 @@ export declare class LibraryApi {
     createPerson(person: Partial<IPerson>): Promise<IPerson>;
     removePerson(personId: string): Promise<void>;
     updatePerson(personId: string, updates: Partial<IPerson>): Promise<IPerson>;
+    getPerson(personId: string): Promise<IPerson>;
     createSerie(serie: Partial<ISerie>): Promise<ISerie>;
     createEpisode(episode: Partial<IEpisode>): Promise<IEpisode>;
     serieScrap(serieId: string, date?: number): Promise<void>;
@@ -198,7 +201,18 @@ export declare class LibraryApi {
     addTagToMedia(mediaId: string, tagId: string): Promise<void>;
     removeTagFromMedia(mediaId: string, tagId: string): Promise<void>;
     getCryptChallenge(): Promise<string>;
-    getChannels(): Promise<any[]>;
+    getChannels(query?: ChannelQuery): Promise<IChannel[]>;
+    getChannel(channelId: string): Promise<IChannel>;
+    deleteChannel(channelId: string): Promise<void>;
+    importChannels(url?: string): Promise<M3uImportResult>;
+    refreshChannels(): Promise<M3uImportResult>;
+    getChannelStreamUrl(channelId: string, quality?: string): string;
+    getChannelHlsUrl(channelId: string, quality?: string): string;
+    stopChannelHls(channelId: string): Promise<void>;
+    getAuthToken(): string;
+    addTagToChannel(channelId: string, tagId: string): Promise<void>;
+    removeTagFromChannel(channelId: string, tagId: string): Promise<void>;
+    getChannelImageUrl(channelId: string, size?: string): string;
     personRename(personId: string, newName: string): Promise<IPerson>;
     personUpdate(personId: string, updates: Partial<IPerson>): Promise<IPerson>;
     personAddAlt(personId: string, alt: string): Promise<IPerson>;
@@ -211,6 +225,10 @@ export declare class LibraryApi {
     serieAddAlt(serieId: string, alt: string): Promise<ISerie>;
     serieRemoveAlt(serieId: string, alt: string): Promise<ISerie>;
     updatePersonPortrait(personId: string, portrait: FormData): Promise<void>;
+    searchPeopleStream(name: string, callbacks: SearchStreamCallbacks<PersonSearchStreamResult>, options?: {
+        source?: string[];
+        pageKey?: string;
+    }): () => void;
     searchSeries(name: string): Promise<SerieSearchResult[]>;
     searchSeriesStream(name: string, callbacks: SearchStreamCallbacks<SerieSearchStreamResult>, options?: {
         source?: string[];
@@ -244,6 +262,22 @@ export declare class LibraryApi {
      * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
      */
     searchMovieMedias(movieId: string, q?: string): Promise<RsGroupDownload[]>;
+    searchEpisodeMediasStream(serieId: string, season: number, episode: number, callbacks: SearchStreamCallbacks<SourceSearchStreamResult>, options?: {
+        source?: string[];
+        pageKey?: string;
+    }): () => void;
+    searchSeasonMediasStream(serieId: string, season: number, callbacks: SearchStreamCallbacks<SourceSearchStreamResult>, options?: {
+        source?: string[];
+        pageKey?: string;
+    }): () => void;
+    searchMovieMediasStream(movieId: string, callbacks: SearchStreamCallbacks<SourceSearchStreamResult>, options?: {
+        source?: string[];
+        pageKey?: string;
+    }): () => void;
+    searchBookMediasStream(bookId: string, callbacks: SearchStreamCallbacks<SourceSearchStreamResult>, options?: {
+        source?: string[];
+        pageKey?: string;
+    }): () => void;
     /**
      * Adds a searched episode media to the database for download/storage.
      * @param serieId - The series identifier
@@ -387,7 +421,6 @@ export declare class LibraryApi {
     mediaUpdateProgress(mediaId: string, progress: number): Promise<{
         progress: number;
     }>;
-    mediaUpdateChannel(mediaId: string, update: IChannelUpdate): Promise<IFile[]>;
     refreshMedia(mediaId: string): Promise<IFile[]>;
     aiTagMedia(mediaId: string): Promise<IFile[]>;
     mediaUpdate(mediaId: string, update: MediaForUpdate): Promise<IFile[]>;
@@ -471,11 +504,14 @@ export declare class LibraryApi {
      * Upload a group of media files from URLs
      * @param download - The group download request containing requests array
      * @param options - Optional settings (spawn: true to run in background)
-     * @returns Array of created media files when spawn=false, or { downloading: true } when spawn=true
+     * @returns Array of created media files, { downloading: true } when spawn=true, or { needFileSelection, request } when file selection is required
      */
     uploadGroup(download: RsGroupDownload, options?: {
         spawn?: boolean;
     }): Promise<IFile[] | {
         downloading: boolean;
+    } | {
+        needFileSelection: true;
+        request: RsRequest;
     }>;
 }

package/dist/library.js

@@ -22,6 +22,7 @@ export class LibraryApi {
         this.mediaRating$ = this.createLibraryFilteredStream(client.mediaRating$);
         this.mediaProgress$ = this.createLibraryFilteredStream(client.mediaProgress$);
         this.requestProcessing$ = this.createLibraryFilteredStream(client.requestProcessing$);
+        this.channels$ = this.createLibraryFilteredStream(client.channels$);
     }
     /**
      * Creates a library-filtered stream from a client stream.
@@ -365,6 +366,10 @@ export class LibraryApi {
         const res = await this.client.patch(this.getUrl(`/people/${personId}`), updates);
         return res.data;
     }
+    async getPerson(personId) {
+        const res = await this.client.get(this.getUrl(`/people/${personId}`));
+        return res.data;
+    }
     async createSerie(serie) {
         const res = await this.client.post(this.getUrl('/series'), serie);
         return res.data;
@@ -540,10 +545,62 @@ export class LibraryApi {
         const res = await this.client.get(this.getUrl('/cryptchallenge'));
         return res.data.value;
     }
-    async getChannels() {
-        const res = await this.client.get(this.getUrl('/channels'));
+    async getChannels(query) {
+        const params = {};
+        if (query?.tag)
+            params.tag = query.tag;
+        if (query?.name)
+            params.name = query.name;
+        const res = await this.client.get(this.getUrl('/channels'), { params });
         return res.data;
     }
+    async getChannel(channelId) {
+        const res = await this.client.get(this.getUrl(`/channels/${channelId}`));
+        return res.data;
+    }
+    async deleteChannel(channelId) {
+        await this.client.delete(this.getUrl(`/channels/${channelId}`));
+    }
+    async importChannels(url) {
+        const res = await this.client.post(this.getUrl('/channels/import'), { url });
+        return res.data;
+    }
+    async refreshChannels() {
+        const res = await this.client.post(this.getUrl('/channels/refresh'), {});
+        return res.data;
+    }
+    getChannelStreamUrl(channelId, quality) {
+        const token = this.client.getAuthToken();
+        const params = { token };
+        if (quality)
+            params.quality = quality;
+        return this.client.getFullUrl(this.getUrl(`/channels/${channelId}/stream`), params);
+    }
+    getChannelHlsUrl(channelId, quality) {
+        const token = this.client.getAuthToken();
+        const params = { token };
+        if (quality)
+            params.quality = quality;
+        return this.client.getFullUrl(this.getUrl(`/channels/${channelId}/hls/playlist.m3u8`), params);
+    }
+    async stopChannelHls(channelId) {
+        await this.client.delete(this.getUrl(`/channels/${channelId}/hls`));
+    }
+    getAuthToken() {
+        return this.client.getAuthToken();
+    }
+    async addTagToChannel(channelId, tagId) {
+        await this.client.post(this.getUrl(`/channels/${channelId}/tags`), { tagId });
+    }
+    async removeTagFromChannel(channelId, tagId) {
+        await this.client.delete(this.getUrl(`/channels/${channelId}/tags/${tagId}`));
+    }
+    getChannelImageUrl(channelId, size) {
+        const params = {};
+        if (size)
+            params.size = size;
+        return this.client.getFullUrl(this.getUrl(`/channels/${channelId}/image`), params);
+    }
     async personRename(personId, newName) {
         const res = await this.client.patch(this.getUrl(`/people/${personId}`), {
             name: newName
@@ -611,6 +668,14 @@ export class LibraryApi {
     async updatePersonPortrait(personId, portrait) {
         await this.client.post(this.getUrl(`/people/${personId}/image?size=thumb&type=poster`), portrait);
     }
+    searchPeopleStream(name, callbacks, options) {
+        const params = { name };
+        if (options?.source?.length)
+            params.source = options.source.join(',');
+        if (options?.pageKey)
+            params.pageKey = options.pageKey;
+        return this.openSearchStream(this.getUrl('/people/searchstream'), params, callbacks);
+    }
     async searchSeries(name) {
         const res = await this.client.get(this.getUrl(`/series/search?name=${name}`));
         return res.data;
@@ -670,6 +735,38 @@ export class LibraryApi {
         const res = await this.client.get(this.getUrl(`/movies/${movieId}/search`), q ? { params: { q } } : undefined);
         return res.data;
     }
+    searchEpisodeMediasStream(serieId, season, episode, callbacks, options) {
+        const params = {};
+        if (options?.source?.length)
+            params.source = options.source.join(',');
+        if (options?.pageKey)
+            params.pageKey = options.pageKey;
+        return this.openSearchStream(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/searchstream`), params, callbacks);
+    }
+    searchSeasonMediasStream(serieId, season, callbacks, options) {
+        const params = {};
+        if (options?.source?.length)
+            params.source = options.source.join(',');
+        if (options?.pageKey)
+            params.pageKey = options.pageKey;
+        return this.openSearchStream(this.getUrl(`/series/${serieId}/seasons/${season}/searchstream`), params, callbacks);
+    }
+    searchMovieMediasStream(movieId, callbacks, options) {
+        const params = {};
+        if (options?.source?.length)
+            params.source = options.source.join(',');
+        if (options?.pageKey)
+            params.pageKey = options.pageKey;
+        return this.openSearchStream(this.getUrl(`/movies/${movieId}/searchstream`), params, callbacks);
+    }
+    searchBookMediasStream(bookId, callbacks, options) {
+        const params = {};
+        if (options?.source?.length)
+            params.source = options.source.join(',');
+        if (options?.pageKey)
+            params.pageKey = options.pageKey;
+        return this.openSearchStream(this.getUrl(`/books/${bookId}/searchstream`), params, callbacks);
+    }
     /**
      * Adds a searched episode media to the database for download/storage.
      * @param serieId - The series identifier
@@ -919,10 +1016,6 @@ export class LibraryApi {
         const res = await this.client.patch(this.getUrl(`/medias/${mediaId}/progress`), { progress });
         return res.data;
     }
-    async mediaUpdateChannel(mediaId, update) {
-        const res = await this.client.patch(this.getUrl(`/medias/${mediaId}/channel`), update);
-        return res.data;
-    }
     async refreshMedia(mediaId) {
         const res = await this.client.get(this.getUrl(`/medias/${mediaId}/metadata/refresh`));
         return res.data;
@@ -1176,14 +1269,14 @@ export class LibraryApi {
      * Upload a group of media files from URLs
      * @param download - The group download request containing requests array
      * @param options - Optional settings (spawn: true to run in background)
-     * @returns Array of created media files when spawn=false, or { downloading: true } when spawn=true
+     * @returns Array of created media files, { downloading: true } when spawn=true, or { needFileSelection, request } when file selection is required
      */
     async uploadGroup(download, options) {
         const params = {};
         if (options?.spawn) {
             params.spawn = 'true';
         }
-        const res = await this.client.post(this.getUrl('/medias/download'), download, { params });
+        const res = await this.client.post(this.getUrl('/medias/download'), download, { params, timeout: 2 * 60 * 60 * 1000 });
         return res.data;
     }
 }

package/dist/server.js

@@ -1,50 +1,34 @@
+import { openFetchSSEStream } from './sse-fetch.js';
 export class ServerApi {
     constructor(client) {
         this.client = client;
     }
     openSearchStream(path, params, callbacks) {
-        const EventSourceCtor = globalThis.EventSource;
-        if (!EventSourceCtor) {
-            callbacks.onError?.(new Error('EventSource is not available in this runtime.'));
-            return () => undefined;
-        }
         const url = this.client.getFullUrl(path, {
             ...params,
             token: this.client.getAuthToken()
         });
-        const source = new EventSourceCtor(url);
-        let closed = false;
-        const close = () => {
-            if (closed) {
-                return;
+        let finished = false;
+        const finish = () => {
+            if (!finished) {
+                finished = true;
+                callbacks.onFinished?.();
             }
-            closed = true;
-            source.removeEventListener('results', onResults);
-            source.removeEventListener('finished', onFinished);
-            source.onerror = null;
-            source.close();
         };
-        const onResults = (event) => {
-            try {
-                const payload = JSON.parse(event.data);
-                callbacks.onResults?.(payload);
+        return openFetchSSEStream(url, (eventType, data) => {
+            if (eventType === 'results') {
+                try {
+                    const payload = JSON.parse(data);
+                    callbacks.onResults?.(payload);
+                }
+                catch (error) {
+                    callbacks.onError?.(error);
+                }
             }
-            catch (error) {
-                callbacks.onError?.(error);
-                close();
+            else if (eventType === 'finished') {
+                finish();
             }
-        };
-        const onFinished = () => {
-            callbacks.onFinished?.();
-            close();
-        };
-        source.addEventListener('results', onResults);
-        source.addEventListener('finished', onFinished);
-        source.onerror = (error) => {
-            callbacks.onError?.(error);
-            close();
-        };
-        return close;
+        }, () => finish(), (error) => callbacks.onError?.(error));
     }
     async getLibraries() {
         const res = await this.client.get('/libraries');

package/dist/sse-types.d.ts

@@ -1,4 +1,4 @@
-import { ILibrary, IFile, IEpisode, ISerie, IMovie, IBook, IPerson, ITag, IBackup, IWatched, IUnwatched, IRsRequestProcessing, VideoConvertRequest, type ItemWithRelations } from './interfaces.js';
+import { ILibrary, IFile, IEpisode, ISerie, IMovie, IBook, IPerson, ITag, IBackup, IWatched, IUnwatched, IRsRequestProcessing, VideoConvertRequest, type ItemWithRelations, type IChannel } from './interfaces.js';
 export type ElementAction = 'Added' | 'Updated' | 'Deleted';
 export type SSEConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
 export interface SSEConnectionOptions {
@@ -98,6 +98,13 @@ export interface SSEMoviesEvent {
         movie: ItemWithRelations<IMovie>;
     }[];
 }
+export interface SSEChannelsEvent {
+    library: string;
+    channels: {
+        action: ElementAction;
+        channel: IChannel;
+    }[];
+}
 export interface SSEBooksEvent {
     library: string;
     books: {
@@ -205,6 +212,7 @@ export interface SSEEventMap {
     'watched': SSEWatchedEvent;
     'unwatched': SSEUnwatchedEvent;
     'request_processing': SSERequestProcessingEvent;
+    'channels': SSEChannelsEvent;
 }
 export type SSEEventName = keyof SSEEventMap;
 export interface SSEEvent<T extends SSEEventName = SSEEventName> {

package/libraries.md

@@ -1812,22 +1812,59 @@ Updates the watch progress for a media file.
 await libraryApi.mediaUpdateProgress('media-id', 50);
 ```
 
-### `mediaUpdateChannel(mediaId: string, update: IChannelUpdate): Promise<IFile[]>`
+### `getChannels(query?: ChannelQuery): Promise<IChannel[]>`
 
-Updates channel information for a media file.
+Lists all channels in the library, optionally filtered by group tag or name.
 
 **Parameters:**
 
-- `mediaId`: The ID of the media
-- `update`: Channel update object
+- `query` (optional): Filter options (`{ tag?: string, name?: string }`)
 
-**Returns:** Promise resolving to an array of updated `IFile` objects
+**Returns:** Promise resolving to an array of `IChannel` objects
 
-**Example:**
+### `getChannel(channelId: string): Promise<IChannel>`
 
-```typescript
-await libraryApi.mediaUpdateChannel('media-id', { channel: 'new-channel' });
-```
+Gets a single channel with its variants.
+
+### `deleteChannel(channelId: string): Promise<void>`
+
+Deletes a channel. Requires admin role.
+
+### `importChannels(url?: string): Promise<M3uImportResult>`
+
+Imports channels from an M3U playlist URL. If no URL is provided, uses the library's configured source.
+
+**Returns:** Promise resolving to `M3uImportResult` with counts of added/updated/removed channels and groups.
+
+### `refreshChannels(): Promise<M3uImportResult>`
+
+Refreshes channels from the library's configured M3U source URL.
+
+### `getChannelStreamUrl(channelId: string, quality?: string): string`
+
+Returns the URL for streaming a channel via MPEG2-TS proxy. Supports quality selection (`4K`, `FHD`, `HD`, `SD`).
+
+### `getChannelHlsUrl(channelId: string, quality?: string): string`
+
+Returns the HLS playlist URL for streaming a channel. The server remuxes the MPEG-TS source into HLS segments using FFmpeg. Supports quality selection (`4K`, `FHD`, `HD`, `SD`).
+
+**Note:** HLS sessions consume server resources. Call `stopChannelHls()` when playback ends.
+
+### `stopChannelHls(channelId: string): Promise<void>`
+
+Stops the server-side HLS session for a channel, terminating FFmpeg and cleaning up temporary segments.
+
+### `addTagToChannel(channelId: string, tagId: string): Promise<void>`
+
+Adds a tag to a channel.
+
+### `removeTagFromChannel(channelId: string, tagId: string): Promise<void>`
+
+Removes a tag from a channel.
+
+### `getChannelImageUrl(channelId: string, size?: string): string`
+
+Returns the URL for a channel's image/logo.
 
 ### `refreshMedia(mediaId: string): Promise<IFile[]>`
 
@@ -2466,16 +2503,17 @@ Gets a cryptographic challenge for encryption verification.
 const challenge = await libraryApi.getCryptChallenge();
 ```
 
-### `getChannels(): Promise<any[]>`
+### `getChannels(query?: ChannelQuery): Promise<IChannel[]>`
 
-Gets all channels (for IPTV libraries).
+Gets all channels (for IPTV libraries), optionally filtered.
 
-**Returns:** Promise resolving to an array of channel objects
+**Returns:** Promise resolving to an array of `IChannel` objects
 
 **Example:**
 
 ```typescript
 const channels = await libraryApi.getChannels();
+const filtered = await libraryApi.getChannels({ tag: 'tag-id' });
 ```
 
 ### `getWatermarks(): Promise<string[]>`

package/package.json

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