@redseat/api 0.0.1

package/dist/encryption.js

@@ -0,0 +1,238 @@
+/**
+ * Cross-platform encryption/decryption functions
+ * Supports the same formats as src/lib/crypt.ts
+ */
+import { getCryptoSubtle, getCryptoRandomValues, uint8ArrayFromBase64Url, arrayBufferToBase64, base64ToBase64Url, } from './crypto';
+// Salt constants matching existing implementation
+const TEXT_SALT = 'a1209660b32cca003630cb963f730b54';
+const FILE_SALT = 'e5709660b22ab0803630cb963f703b83';
+/**
+ * Derive a CryptoKey from a passphrase using PBKDF2
+ * @param passPhrase - The passphrase to derive the key from
+ * @param type - 'text' for text encryption, 'file' for file encryption
+ * @returns A CryptoKey suitable for AES-CBC encryption/decryption
+ */
+export async function deriveKey(passPhrase, type) {
+    const crypto = getCryptoSubtle();
+    const saltB64 = type === 'text' ? TEXT_SALT : FILE_SALT;
+    const saltBuffer = uint8ArrayFromBase64Url(saltB64);
+    const passphraseKey = new TextEncoder().encode(passPhrase);
+    // Import the passphrase as a key for PBKDF2
+    const keyMaterial = await crypto.importKey('raw', passphraseKey, {
+        name: 'PBKDF2',
+    }, false, ['deriveBits', 'deriveKey']);
+    // Derive the actual encryption key
+    // Normalize saltBuffer to ensure it's a proper BufferSource
+    const salt = saltBuffer instanceof Uint8Array ? new Uint8Array(saltBuffer) : saltBuffer;
+    return await crypto.deriveKey({
+        name: 'PBKDF2',
+        salt: salt,
+        iterations: 1000,
+        hash: 'SHA-1',
+    }, keyMaterial, {
+        name: 'AES-CBC',
+        length: 256,
+    }, false, ['encrypt', 'decrypt']);
+}
+/**
+ * Generate a random 16-byte IV (Initialization Vector)
+ */
+export function getRandomIV() {
+    const getRandomValues = getCryptoRandomValues();
+    return getRandomValues(new Uint8Array(16));
+}
+/**
+ * Encrypt a text string
+ * Returns format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+ */
+export async function encryptText(key, text) {
+    const crypto = getCryptoSubtle();
+    const iv = getRandomIV();
+    const textData = new TextEncoder().encode(text);
+    // Normalize iv to ensure it's a proper BufferSource
+    const ivBuffer = new Uint8Array(iv);
+    const encrypted = await crypto.encrypt({
+        name: 'AES-CBC',
+        iv: ivBuffer,
+    }, key, textData);
+    const ivB64 = base64ToBase64Url(arrayBufferToBase64(iv));
+    const encryptedB64 = base64ToBase64Url(arrayBufferToBase64(encrypted));
+    return `${ivB64}.${encryptedB64}`;
+}
+/**
+ * Decrypt a text string
+ * Expects format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+ * Or can accept IV separately
+ */
+export async function decryptText(key, encryptedText, iv) {
+    const crypto = getCryptoSubtle();
+    let extractedIv;
+    let encryptedData;
+    if (iv) {
+        extractedIv = iv;
+        encryptedData = encryptedText;
+    }
+    else {
+        const parts = encryptedText.split('.');
+        if (parts.length !== 2) {
+            throw new Error('Invalid encrypted text format. Expected format: IV.encryptedData');
+        }
+        extractedIv = uint8ArrayFromBase64Url(parts[0]);
+        encryptedData = parts[1];
+    }
+    const encryptedBuffer = uint8ArrayFromBase64Url(encryptedData);
+    // Normalize iv and buffer to ensure they're proper BufferSource
+    const ivBuffer = extractedIv instanceof Uint8Array ? new Uint8Array(extractedIv) : extractedIv;
+    const bufferSource = encryptedBuffer instanceof Uint8Array ? new Uint8Array(encryptedBuffer) : encryptedBuffer;
+    const decrypted = await crypto.decrypt({
+        name: 'AES-CBC',
+        iv: ivBuffer,
+    }, key, bufferSource);
+    return new TextDecoder('utf-8').decode(decrypted);
+}
+/**
+ * Encrypt a buffer (ArrayBuffer or Uint8Array)
+ */
+export async function encryptBuffer(key, iv, buffer) {
+    const crypto = getCryptoSubtle();
+    // Normalize iv and buffer to ensure they're proper BufferSource
+    const ivBuffer = iv instanceof Uint8Array ? new Uint8Array(iv) : iv;
+    const bufferSource = buffer instanceof Uint8Array ? new Uint8Array(buffer) : buffer;
+    return await crypto.encrypt({
+        name: 'AES-CBC',
+        iv: ivBuffer,
+    }, key, bufferSource);
+}
+/**
+ * Decrypt a buffer (ArrayBuffer or Uint8Array)
+ */
+export async function decryptBuffer(key, iv, buffer) {
+    const crypto = getCryptoSubtle();
+    // Normalize iv and buffer to ensure they're proper BufferSource
+    const ivBuffer = iv instanceof Uint8Array ? new Uint8Array(iv) : iv;
+    const bufferSource = buffer instanceof Uint8Array ? new Uint8Array(buffer) : buffer;
+    return await crypto.decrypt({
+        name: 'AES-CBC',
+        iv: ivBuffer,
+    }, key, bufferSource);
+}
+/**
+ * Encrypt a file with thumbnail and metadata
+ * Structure: [16 bytes IV][4 bytes thumb size][4 bytes info size][32 bytes thumb mime][256 bytes file mime][T bytes encrypted thumb][I bytes encrypted info][encrypted file data]
+ */
+export async function encryptFile(key, options) {
+    const iv = getRandomIV();
+    // Encrypt thumbnail and file buffer
+    const encThumb = await encryptBuffer(key, iv, options.thumb);
+    const encBuffer = await encryptBuffer(key, iv, options.buffer);
+    // Create metadata buffers
+    const thumbMimeBuffer = stringToArrayBuffer(options.thumbMime, 32);
+    const fileMimeBuffer = stringToArrayBuffer(options.mime, 256);
+    // Create the encrypted file structure
+    // Use big-endian to match toBytesInt32 behavior (false = big-endian in DataView API)
+    const thumbSizeBytes = new ArrayBuffer(4);
+    new DataView(thumbSizeBytes).setInt32(0, encThumb.byteLength, false); // big-endian (false = big-endian)
+    const infoSizeBytes = new ArrayBuffer(4);
+    new DataView(infoSizeBytes).setInt32(0, 0, false); // info size is 0, big-endian
+    // Combine all parts
+    const totalLength = 16 + 4 + 4 + 32 + 256 + encThumb.byteLength + 0 + encBuffer.byteLength;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    // IV (16 bytes)
+    result.set(new Uint8Array(iv), offset);
+    offset += 16;
+    // Thumb size (4 bytes)
+    result.set(new Uint8Array(thumbSizeBytes), offset);
+    offset += 4;
+    // Info size (4 bytes)
+    result.set(new Uint8Array(infoSizeBytes), offset);
+    offset += 4;
+    // Thumb mime (32 bytes)
+    result.set(new Uint8Array(thumbMimeBuffer), offset);
+    offset += 32;
+    // File mime (256 bytes)
+    result.set(new Uint8Array(fileMimeBuffer), offset);
+    offset += 256;
+    // Encrypted thumb
+    result.set(new Uint8Array(encThumb), offset);
+    offset += encThumb.byteLength;
+    // Encrypted file data
+    result.set(new Uint8Array(encBuffer), offset);
+    // Encrypt filename
+    const binaryFilename = new TextEncoder().encode(options.filename);
+    const encFilename = await encryptBuffer(key, iv, binaryFilename);
+    const filenameB64 = base64ToBase64Url(arrayBufferToBase64(encFilename));
+    return {
+        filename: filenameB64,
+        ivb64: arrayBufferToBase64(iv),
+        thumbsize: encThumb.byteLength,
+        blob: result.buffer,
+    };
+}
+/**
+ * Decrypt a file buffer
+ * Extracts and decrypts the file data from the encrypted file structure
+ */
+export async function decryptFile(key, buffer) {
+    const crypto = getCryptoSubtle();
+    const dv = new DataView(buffer, 0);
+    const iv = buffer.slice(0, 16);
+    // Read thumb size (handle endianness - try big-endian first since we write big-endian, then little-endian for backward compatibility)
+    let targetThumbSize = dv.getInt32(16, false); // big-endian (default, matches toBytesInt32)
+    if (targetThumbSize > 999999 || targetThumbSize < 0) {
+        targetThumbSize = dv.getInt32(16, true); // little-endian fallback for backward compatibility
+    }
+    const infoSize = dv.getInt32(20, false); // big-endian (default, matches toBytesInt32)
+    // Calculate offset to encrypted file data
+    const fileDataOffset = 16 + 4 + 4 + 32 + 256 + targetThumbSize + infoSize;
+    const encryptedFileData = buffer.slice(fileDataOffset);
+    return await crypto.decrypt({
+        name: 'AES-CBC',
+        iv: iv,
+    }, key, encryptedFileData);
+}
+/**
+ * Decrypt a file thumbnail
+ * Extracts and decrypts the thumbnail from the encrypted file structure
+ */
+export async function decryptFileThumb(key, buffer) {
+    const crypto = getCryptoSubtle();
+    const dv = new DataView(buffer, 0);
+    const iv = buffer.slice(0, 16);
+    // Read thumb size (big-endian first to match toBytesInt32, then little-endian fallback)
+    let thumbSize = dv.getInt32(16, false); // big-endian (matches toBytesInt32 which uses false)
+    if (thumbSize > 999999 || thumbSize < 0) {
+        thumbSize = dv.getInt32(16, true); // little-endian fallback for backward compatibility
+    }
+    // If thumbSize is 0, return empty buffer
+    if (thumbSize === 0) {
+        return new ArrayBuffer(0);
+    }
+    // Encrypted thumb starts after: IV (16) + thumbSize (4) + infoSize (4) + thumbMime (32) + fileMime (256) = 312
+    const thumbOffset = 16 + 4 + 4 + 32 + 256;
+    const encryptedThumb = buffer.slice(thumbOffset, thumbOffset + thumbSize);
+    return await crypto.decrypt({
+        name: 'AES-CBC',
+        iv: iv,
+    }, key, encryptedThumb);
+}
+/**
+ * Encrypt a filename
+ * Returns base64url encoded encrypted filename
+ */
+export async function encryptFilename(key, filename, iv) {
+    const binaryFilename = new TextEncoder().encode(filename);
+    const encFilename = await encryptBuffer(key, iv, binaryFilename);
+    return base64ToBase64Url(arrayBufferToBase64(encFilename));
+}
+/**
+ * Helper function to convert string to ArrayBuffer with fixed length
+ */
+function stringToArrayBuffer(str, length) {
+    const buffer = new ArrayBuffer(length);
+    const view = new Uint8Array(buffer);
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(str);
+    view.set(encoded.slice(0, length));
+    return buffer;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './client';
+export * from './auth';
+export * from './interfaces';
+export * from './library';
+export * from './server';
+export * from './crypto';
+export * from './encryption';
+export * from './upload';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './client';
+export * from './auth';
+export * from './interfaces';
+export * from './library';
+export * from './server';
+export * from './crypto';
+export * from './encryption';
+export * from './upload';

package/dist/interfaces.d.ts

@@ -0,0 +1,311 @@
+export declare enum FileTypes {
+    directory = "directory",
+    photo = "photo",
+    video = "video",
+    archive = "archive",
+    album = "album",
+    channel = "channel",
+    other = "other"
+}
+export interface SerieInMedia {
+    id: string;
+    season?: number;
+    episode?: number;
+    episodeTo?: number;
+}
+export interface IFile {
+    id: string;
+    name: string;
+    description?: string;
+    size: number;
+    type: FileTypes;
+    mimetype: string;
+    modified: number;
+    created: number;
+    added: number;
+    starred?: any;
+    width: number;
+    height: number;
+    phash?: string;
+    thumbhash?: string;
+    acodecs?: string[];
+    achan?: number[];
+    vcodecs?: string[];
+    fps?: number;
+    bitrate?: number;
+    colorSpace?: string;
+    icc?: string;
+    mp?: number;
+    focal?: number;
+    iso?: number;
+    fNumber?: number;
+    sspeed?: string;
+    orientation?: number;
+    duration?: any;
+    progress?: number;
+    thumb?: any;
+    rating?: number;
+    tags?: {
+        id: string;
+        conf?: number;
+    }[];
+    people?: {
+        id: string;
+        conf?: number;
+    }[];
+    series?: SerieInMedia[];
+    movie?: string;
+    long?: number;
+    lat?: number;
+    params?: any;
+    iv?: string;
+    pages?: number;
+    thumbv?: number;
+    thumbsize?: number;
+    model?: string;
+    originalId?: string;
+}
+export declare enum LibraryTypes {
+    'Photos' = "photos",
+    'Shows' = "shows",
+    'Movies' = "movies",
+    'IPTV' = "iptv"
+}
+export declare enum LibrarySources {
+    'Path' = "PathProvider",
+    'Virtual' = "VirtualProvider",
+    'Plugin' = "PluginProvider"
+}
+export declare enum LibraryRole {
+    none = "none",
+    display = "display",
+    read = "read",
+    write = "write",
+    share = "share",
+    admin = "admin"
+}
+export interface ILibrary {
+    id?: string;
+    name: string;
+    type: LibraryTypes;
+    source?: LibrarySources;
+    roles?: LibraryRole[];
+    crypt?: boolean;
+    hidden?: boolean;
+    status?: string;
+}
+export interface ITag {
+    id?: string;
+    name: string;
+    parent?: string;
+    path?: string;
+    count?: number;
+    starred?: boolean;
+    hidden?: boolean;
+    alt?: string[];
+    generated?: boolean;
+    waiting?: boolean;
+}
+export declare enum LinkType {
+    'profile' = "profile",
+    'post' = "post",
+    'other' = "other"
+}
+export interface IPerson {
+    id?: string;
+    name: string;
+    alt?: string[];
+    socials?: {
+        id: string;
+        type: LinkType | undefined;
+        platform: string;
+    }[];
+    posterv?: number;
+    portrait?: boolean;
+    birthday?: number;
+    waiting?: boolean;
+    generated?: boolean;
+}
+export interface ISerie {
+    id?: string;
+    name: string;
+    alt?: string[];
+    tags?: string[];
+    people?: string[];
+    year?: number;
+    poster?: boolean;
+    imdb?: string;
+    slug?: string;
+    tmdb?: number;
+    trakt?: number;
+    tvdb?: number;
+    otherids?: string;
+    status?: string;
+    imdbRating?: number;
+    imdbVotes?: number;
+    images?: {
+        poster?: string;
+        background?: string;
+    };
+    posterv?: number;
+    backgroundv?: number;
+    cardv?: number;
+    waiting?: boolean;
+}
+export interface IEpisode {
+    id?: string;
+    serie: string;
+    name: string;
+    season?: number;
+    number?: number;
+    abs?: number;
+    overview?: string;
+    airdate?: number;
+    duration?: number;
+    type?: string;
+    alt?: string[];
+    imdb?: string;
+    slug?: string;
+    tmdb?: number;
+    trakt?: number;
+    tvdb?: number;
+    otherids?: string;
+    modified?: number;
+    watched?: number;
+    images?: {
+        poster?: string;
+        background?: string;
+    };
+}
+export interface IMovie {
+    id?: string;
+    name: string;
+    year?: number;
+}
+export interface IServer {
+    id: string;
+    name: string;
+    url: string;
+    port?: number;
+}
+export interface MediaRequest {
+    sort?: string;
+    order?: 'ASC' | 'DESC';
+    tags?: string[];
+    people?: string[];
+    series?: string[];
+    movies?: string[];
+    minSize?: number;
+    maxSize?: number;
+    pageKey?: string;
+    limit?: number;
+}
+export interface IBackup {
+    id: string;
+    name: string;
+    path: string;
+    password?: string;
+    library: string;
+    source: string;
+    plugin?: string;
+    credentials?: string;
+    credentialsName?: string;
+    schedule: string;
+    filter?: MediaRequest;
+    last?: number;
+    size?: number;
+}
+export interface IBackupFile {
+    backup: string;
+    library: string;
+    file: string;
+    id?: string;
+    path?: string;
+    hash?: string;
+    sourcehash?: string;
+    size?: number;
+    added: number;
+    modified: number;
+    iv?: string;
+    thumbsize?: number;
+    infoSize?: number;
+    error?: string;
+}
+export interface ExternalImage {
+    url: string;
+    type: string;
+}
+export interface IChannel {
+    id: string;
+    name: string;
+    series: string[];
+    lang?: string;
+    versions: IChannelVersion[];
+    type?: FileTypes;
+}
+export interface IChannelVersion {
+    id: string;
+    name: string;
+    source: string;
+    quality?: string;
+    description?: string;
+}
+export interface UnassignedFace {
+    id: string;
+    media: string;
+    box: any;
+    confidence: number;
+}
+export interface UnassignedFacesResponse {
+    faces: UnassignedFace[];
+    total: number;
+}
+export interface Cluster {
+    id: string;
+    faces: UnassignedFace[];
+    representativeFace: UnassignedFace;
+}
+export interface AssignFacesRequest {
+    faceIds: string[];
+    personId: string;
+}
+export interface AssignFacesResponse {
+    assigned: number;
+}
+export interface CreatePersonFromClusterRequest {
+    name?: string;
+}
+export interface CreatePersonFromClusterResponse {
+    person: IPerson;
+}
+export interface SplitClusterRequest {
+    faceIds?: string[];
+}
+export interface SplitClusterResponse {
+    newClusters: Cluster[];
+}
+export interface UnassignFaceRequest {
+    reason?: string;
+}
+export interface UnassignFaceResponse {
+    unassigned: number;
+}
+export interface DeleteFaceResponse {
+    deleted: number;
+}
+export interface AssignedFace extends UnassignedFace {
+    person: IPerson;
+}
+export interface MergePeopleRequest {
+    sourcePersonId: string;
+    targetPersonId: string;
+}
+export interface MergePeopleResponse {
+    merged: boolean;
+}
+export interface ClusterFacesResponse {
+    clusters: number;
+}
+export interface IChannelUpdate {
+    [key: string]: any;
+}

package/dist/interfaces.js

@@ -0,0 +1,38 @@
+export var FileTypes;
+(function (FileTypes) {
+    FileTypes["directory"] = "directory";
+    FileTypes["photo"] = "photo";
+    FileTypes["video"] = "video";
+    FileTypes["archive"] = "archive";
+    FileTypes["album"] = "album";
+    FileTypes["channel"] = "channel";
+    FileTypes["other"] = "other";
+})(FileTypes || (FileTypes = {}));
+export var LibraryTypes;
+(function (LibraryTypes) {
+    LibraryTypes["Photos"] = "photos";
+    LibraryTypes["Shows"] = "shows";
+    LibraryTypes["Movies"] = "movies";
+    LibraryTypes["IPTV"] = "iptv";
+})(LibraryTypes || (LibraryTypes = {}));
+export var LibrarySources;
+(function (LibrarySources) {
+    LibrarySources["Path"] = "PathProvider";
+    LibrarySources["Virtual"] = "VirtualProvider";
+    LibrarySources["Plugin"] = "PluginProvider";
+})(LibrarySources || (LibrarySources = {}));
+export var LibraryRole;
+(function (LibraryRole) {
+    LibraryRole["none"] = "none";
+    LibraryRole["display"] = "display";
+    LibraryRole["read"] = "read";
+    LibraryRole["write"] = "write";
+    LibraryRole["share"] = "share";
+    LibraryRole["admin"] = "admin";
+})(LibraryRole || (LibraryRole = {}));
+export var LinkType;
+(function (LinkType) {
+    LinkType["profile"] = "profile";
+    LinkType["post"] = "post";
+    LinkType["other"] = "other";
+})(LinkType || (LinkType = {}));