@redseat/api 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,32 @@
+import { Method, AxiosRequestConfig } from 'axios';
+import { IToken } from './auth';
+import { IServer } from './interfaces';
+export interface ClientOptions {
+    server: IServer;
+    getIdToken: () => Promise<string>;
+    refreshThreshold?: number;
+}
+export declare class RedseatClient {
+    private readonly axios;
+    private readonly server;
+    private readonly getIdToken;
+    private readonly refreshThreshold;
+    private baseUrl;
+    private localServerUrl?;
+    private tokenData?;
+    private tokenRefreshPromise?;
+    constructor(options: ClientOptions);
+    private getRegularServerUrl;
+    private detectLocalUrl;
+    private get serverId();
+    private isTokenExpiredOrExpiringSoon;
+    private refreshToken;
+    private ensureValidToken;
+    setToken(token: string | IToken): void;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+    request<T = unknown>(method: Method, url: string, data?: unknown, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<T, any>>;
+}

package/dist/client.js

@@ -0,0 +1,157 @@
+import axios from 'axios';
+import { fetchServerToken } from './auth';
+export class RedseatClient {
+    constructor(options) {
+        this.server = options.server;
+        this.getIdToken = options.getIdToken;
+        this.refreshThreshold = options.refreshThreshold ?? 5 * 60 * 1000; // 5 minutes default
+        // Initialize with regular URL, will be updated after local detection
+        this.baseUrl = this.getRegularServerUrl();
+        this.axios = axios.create({
+            baseURL: this.baseUrl,
+        });
+        // Detect local URL asynchronously and update axios instance
+        this.detectLocalUrl().then((url) => {
+            if (url !== this.baseUrl) {
+                this.baseUrl = url;
+                this.axios.defaults.baseURL = url;
+            }
+        }).catch(() => {
+            // If detection fails, use regular URL (already set)
+        });
+        // Request interceptor: check token expiration and refresh if needed
+        this.axios.interceptors.request.use(async (config) => {
+            await this.ensureValidToken();
+            if (this.tokenData) {
+                config.headers.Authorization = `Bearer ${this.tokenData.token}`;
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        // Response interceptor: handle 401 errors and retry with refreshed token
+        this.axios.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            if (error.response?.status === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                try {
+                    await this.refreshToken();
+                    if (this.tokenData && originalRequest.headers) {
+                        originalRequest.headers.Authorization = `Bearer ${this.tokenData.token}`;
+                    }
+                    return this.axios(originalRequest);
+                }
+                catch (refreshError) {
+                    return Promise.reject(refreshError);
+                }
+            }
+            return Promise.reject(error);
+        });
+    }
+    getRegularServerUrl() {
+        let base = this.server.url;
+        if (this.server.port) {
+            base = `${base}:${this.server.port}`;
+        }
+        return `https://${base}`;
+    }
+    async detectLocalUrl() {
+        let localBase = `local.${this.server.url}`;
+        if (this.server.port) {
+            localBase = `${localBase}:${this.server.port}`;
+        }
+        const localUrl = `https://${localBase}`;
+        try {
+            console.log('trying local server url', localUrl);
+            const response = await axios.get(`${localUrl}/ping`, {
+                timeout: 200,
+                headers: { "Referrer-Policy": 'origin-when-cross-origin' }
+            });
+            if (response.status === 200) {
+                console.log('local server detected');
+                this.localServerUrl = localUrl;
+                return localUrl;
+            }
+            else {
+                console.warn('could not use server locally, status: ', response.status);
+                return this.getRegularServerUrl();
+            }
+        }
+        catch (e) {
+            console.log('could not detect server localhost', e);
+            return this.getRegularServerUrl();
+        }
+    }
+    get serverId() {
+        return this.server.id;
+    }
+    isTokenExpiredOrExpiringSoon() {
+        if (!this.tokenData) {
+            return true;
+        }
+        const now = Date.now();
+        const expirationTime = this.tokenData.expires - this.refreshThreshold;
+        return now >= expirationTime;
+    }
+    async refreshToken() {
+        // If a refresh is already in progress, return the existing promise
+        if (this.tokenRefreshPromise) {
+            return this.tokenRefreshPromise;
+        }
+        this.tokenRefreshPromise = (async () => {
+            try {
+                const idToken = await this.getIdToken();
+                // Use fetchServerToken which uses the global axios instance
+                // The token endpoint is on the frontend server, not the backend server
+                const newToken = await fetchServerToken(this.serverId, idToken);
+                this.tokenData = newToken;
+                return newToken;
+            }
+            finally {
+                // Clear the promise so future calls can trigger a new refresh
+                this.tokenRefreshPromise = undefined;
+            }
+        })();
+        return this.tokenRefreshPromise;
+    }
+    async ensureValidToken() {
+        if (this.isTokenExpiredOrExpiringSoon()) {
+            await this.refreshToken();
+        }
+    }
+    setToken(token) {
+        if (typeof token === 'string') {
+            // When setting token externally as string, we don't know the expiration
+            // So we'll treat it as needing refresh soon
+            this.tokenData = {
+                token,
+                expires: Date.now() + this.refreshThreshold
+            };
+        }
+        else {
+            // When setting full IToken object, use the provided expiration
+            this.tokenData = token;
+        }
+    }
+    async get(url, config) {
+        return this.axios.get(url, config);
+    }
+    async post(url, data, config) {
+        return this.axios.post(url, data, config);
+    }
+    async put(url, data, config) {
+        return this.axios.put(url, data, config);
+    }
+    async patch(url, data, config) {
+        return this.axios.patch(url, data, config);
+    }
+    async delete(url, config) {
+        return this.axios.delete(url, config);
+    }
+    async request(method, url, data, config) {
+        return this.axios.request({
+            method,
+            url,
+            data,
+            ...config
+        });
+    }
+}

package/dist/crypto.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Cross-platform crypto utilities
+ * Works on Node.js, Web browsers, and React Native (Expo)
+ */
+/**
+ * Get the crypto.subtle API available in the current environment
+ */
+export declare function getCryptoSubtle(): SubtleCrypto;
+/**
+ * Get the crypto.getRandomValues API
+ */
+export declare function getCryptoRandomValues(): (array: Uint8Array) => Uint8Array;
+/**
+ * Convert base64 string to Uint8Array (cross-platform)
+ */
+export declare function uint8ArrayFromBase64(base64: string): Uint8Array;
+/**
+ * Convert base64url string to Uint8Array (cross-platform)
+ */
+export declare function uint8ArrayFromBase64Url(base64Url: string): Uint8Array;
+/**
+ * Convert ArrayBuffer to base64 string (cross-platform)
+ */
+export declare function arrayBufferToBase64(buffer: ArrayBuffer | Uint8Array): string;
+/**
+ * Convert base64 to base64url
+ */
+export declare function base64ToBase64Url(base64: string): string;
+/**
+ * Convert base64url to base64 with proper padding
+ */
+export declare function base64UrlToBase64(base64Url: string): string;
+/**
+ * Pad string to the right
+ */
+export declare function padRight(text: string, n: number, pad: string): string;

package/dist/crypto.js

@@ -0,0 +1,164 @@
+/**
+ * Cross-platform crypto utilities
+ * Works on Node.js, Web browsers, and React Native (Expo)
+ */
+// Initialize atob/btoa fallbacks
+let atob;
+let btoa;
+if (typeof globalThis !== 'undefined' && globalThis.atob && globalThis.btoa) {
+    atob = globalThis.atob;
+    btoa = globalThis.btoa;
+}
+else if (typeof window !== 'undefined' && window.atob && window.btoa) {
+    atob = window.atob;
+    btoa = window.btoa;
+}
+else {
+    // Fallback implementation (shouldn't be needed in modern environments)
+    atob = (str) => {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(str, 'base64').toString('binary');
+        }
+        throw new Error('atob is not available and no fallback could be found');
+    };
+    btoa = (str) => {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(str, 'binary').toString('base64');
+        }
+        throw new Error('btoa is not available and no fallback could be found');
+    };
+}
+/**
+ * Get the crypto.subtle API available in the current environment
+ */
+export function getCryptoSubtle() {
+    // Try different ways to access crypto.subtle
+    if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
+        return globalThis.crypto.subtle;
+    }
+    if (typeof window !== 'undefined' && window.crypto?.subtle) {
+        return window.crypto.subtle;
+    }
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        return crypto.subtle;
+    }
+    // Node.js fallback
+    if (typeof require !== 'undefined') {
+        try {
+            const nodeCrypto = require('crypto');
+            if (nodeCrypto.webcrypto?.subtle) {
+                return nodeCrypto.webcrypto.subtle;
+            }
+        }
+        catch (e) {
+            // require not available
+        }
+    }
+    throw new Error('crypto.subtle is not available in this environment');
+}
+/**
+ * Get the crypto.getRandomValues API
+ */
+export function getCryptoRandomValues() {
+    if (typeof globalThis !== 'undefined' && globalThis.crypto?.getRandomValues) {
+        return globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+    }
+    if (typeof window !== 'undefined' && window.crypto?.getRandomValues) {
+        return window.crypto.getRandomValues.bind(window.crypto);
+    }
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        return crypto.getRandomValues.bind(crypto);
+    }
+    // Node.js fallback
+    if (typeof require !== 'undefined') {
+        try {
+            const nodeCrypto = require('crypto');
+            if (nodeCrypto.webcrypto?.getRandomValues) {
+                return nodeCrypto.webcrypto.getRandomValues.bind(nodeCrypto.webcrypto);
+            }
+            if (nodeCrypto.randomFillSync) {
+                // Fallback for older Node.js
+                return (array) => {
+                    nodeCrypto.randomFillSync(array);
+                    return array;
+                };
+            }
+        }
+        catch (e) {
+            // require not available
+        }
+    }
+    throw new Error('crypto.getRandomValues is not available in this environment');
+}
+/**
+ * Convert base64 string to Uint8Array (cross-platform)
+ */
+export function uint8ArrayFromBase64(base64) {
+    // Normalize base64 (handle base64url)
+    const normalized = base64.replace(/-/g, '+').replace(/_/g, '/');
+    // Node.js path
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(normalized, 'base64'));
+    }
+    // Browser/RN path - manual conversion
+    const binary = atob(normalized);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Convert base64url string to Uint8Array (cross-platform)
+ */
+export function uint8ArrayFromBase64Url(base64Url) {
+    // Convert base64url to base64
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    // Add padding if needed
+    const padding = (4 - (base64.length % 4)) % 4;
+    const padded = base64 + '='.repeat(padding);
+    return uint8ArrayFromBase64(padded);
+}
+/**
+ * Convert ArrayBuffer to base64 string (cross-platform)
+ */
+export function arrayBufferToBase64(buffer) {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    // Node.js path
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    // Browser/RN path - manual conversion
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+/**
+ * Convert base64 to base64url
+ */
+export function base64ToBase64Url(base64) {
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+/**
+ * Convert base64url to base64 with proper padding
+ */
+export function base64UrlToBase64(base64Url) {
+    let base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    // Add padding
+    const padding = (4 - (base64.length % 4)) % 4;
+    return base64 + '='.repeat(padding);
+}
+/**
+ * Pad string to the right
+ */
+export function padRight(text, n, pad) {
+    let t = text;
+    if (n > text.length) {
+        for (let i = 0; i < n - text.length; i++) {
+            t += pad;
+        }
+    }
+    return t;
+}

package/dist/encryption.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Cross-platform encryption/decryption functions
+ * Supports the same formats as src/lib/crypt.ts
+ */
+/**
+ * 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 declare function deriveKey(passPhrase: string, type: 'text' | 'file'): Promise<CryptoKey>;
+/**
+ * Generate a random 16-byte IV (Initialization Vector)
+ */
+export declare function getRandomIV(): Uint8Array;
+/**
+ * Encrypt a text string
+ * Returns format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+ */
+export declare function encryptText(key: CryptoKey, text: string): Promise<string>;
+/**
+ * Decrypt a text string
+ * Expects format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+ * Or can accept IV separately
+ */
+export declare function decryptText(key: CryptoKey, encryptedText: string, iv?: ArrayBuffer | Uint8Array): Promise<string>;
+/**
+ * Encrypt a buffer (ArrayBuffer or Uint8Array)
+ */
+export declare function encryptBuffer(key: CryptoKey, iv: ArrayBuffer | Uint8Array, buffer: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+/**
+ * Decrypt a buffer (ArrayBuffer or Uint8Array)
+ */
+export declare function decryptBuffer(key: CryptoKey, iv: ArrayBuffer | Uint8Array, buffer: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+/**
+ * Options for encrypting a file
+ */
+export interface EncryptFileOptions {
+    filename: string;
+    buffer: ArrayBuffer | Uint8Array;
+    thumbMime: string;
+    thumb: ArrayBuffer | Uint8Array;
+    mime: string;
+}
+/**
+ * Result of encrypting a file
+ */
+export interface EncryptedFile {
+    filename: string;
+    ivb64: string;
+    thumbsize: number;
+    blob: ArrayBuffer;
+}
+/**
+ * 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 declare function encryptFile(key: CryptoKey, options: EncryptFileOptions): Promise<EncryptedFile>;
+/**
+ * Decrypt a file buffer
+ * Extracts and decrypts the file data from the encrypted file structure
+ */
+export declare function decryptFile(key: CryptoKey, buffer: ArrayBuffer): Promise<ArrayBuffer>;
+/**
+ * Decrypt a file thumbnail
+ * Extracts and decrypts the thumbnail from the encrypted file structure
+ */
+export declare function decryptFileThumb(key: CryptoKey, buffer: ArrayBuffer): Promise<ArrayBuffer>;
+/**
+ * Encrypt a filename
+ * Returns base64url encoded encrypted filename
+ */
+export declare function encryptFilename(key: CryptoKey, filename: string, iv: ArrayBuffer | Uint8Array): Promise<string>;