bytex-sdk 1.7.6 → 1.8.1

package/index.js

@@ -3,17 +3,7 @@ import { createClient } from '@supabase/supabase-js';
 const SUPABASE_URL = 'https://vkiddclfbwmslaiyyftl.supabase.co';
 const SUPABASE_ANON_KEY = 'sb_publishable_hXMlH9OmJG1_n1s-3lbXKg_6V-88Lj9';
 const WORKER_URL = 'https://api.bytex.work/';
-const DEFAULT_ENC_KEY = 'btx-default-secret-key-32-chars!!';
-const DEFAULT_IV = 'btx-fixed-iv-16b';
 
-/**
- * ByteX Cloud SDK — Full-featured client for the ByteX Storage Platform.
- * Supports upload, download, streaming, encryption, bulk ops, and more.
- * 
- * @example
- * const bytex = new BytexCloud({ apiKey: 'BTX-USER-XXXXXXXX' });
- * await bytex.upload('photo.jpg', fileData);
- */
 export class BytexCloud {
   constructor(config = {}) {
     this.apiKey = config.apiKey || null;
@@ -24,7 +14,6 @@ export class BytexCloud {
       const url = config.supabaseUrl || SUPABASE_URL;
       const key = config.supabaseKey || SUPABASE_ANON_KEY;
       
-      // Add custom storage support for React Native
       const supabaseConfig = {
         auth: {
           persistSession: true,
@@ -37,775 +26,130 @@ export class BytexCloud {
       }
       
       this.supabase = createClient(url, key, supabaseConfig);
-    } else if (this.provider === 'firebase') {
-      this.fbProjectId = config.fbProjectId;
-      this.fbApiKey = config.fbApiKey;
     }
-
     this.user = null;
     this._listeners = {};
-    this._middlewares = [];
-    this._projectScope = 'production';
-  }
-
-  /**
-   * Dynamically update infrastructure settings (BYOC).
-   * @param {object} config - { supabaseUrl, supabaseKey, workerUrl, dbProvider }
-   */
-  configure(config = {}) {
-    if (config.workerUrl) this.workerUrl = config.workerUrl;
-    if (config.dbProvider) this.provider = config.dbProvider;
-    
-    if (this.provider === 'supabase' && (config.supabaseUrl || config.supabaseKey)) {
-      const url = config.supabaseUrl || this.supabase.supabaseUrl;
-      const key = config.supabaseKey || this.supabase.supabaseKey;
-      this.supabase = createClient(url, key);
-    }
-    console.log('[ByteX SDK] Configuration updated.');
   }
 
-  // ─────────────────────────────────────────────
-  //  SECTION 1: AUTHENTICATION
-  // ─────────────────────────────────────────────
-
   async login(email, password) {
-    if (this.provider === 'firebase') {
-      const res = await fetch(`https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=${this.fbApiKey}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ email, password, returnSecureToken: true })
-      });
-      const data = await res.json();
-      if (data.error) throw new Error(`Login Failed: ${data.error.message}`);
-      this.user = { id: data.localId, email: data.email };
-      this.session = data.idToken;
-      this._emit('login', this.user);
-      return this.user;
-    } else {
-      const { data, error } = await this.supabase.auth.signInWithPassword({ email, password });
-      if (error) throw new Error(`Login Failed: ${error.message}`);
-      this.user = data.user;
-      this._emit('login', this.user);
-      return this.user;
-    }
-  }
-
-  /**
-   * Sign out and clear the current session.
-   */
-  async logout() {
-    await this.supabase.auth.signOut();
-    this.user = null;
-    this.apiKey = null;
-    this._emit('logout');
-  }
-
-  /**
-   * Get the current user's profile from the database.
-   * @returns {object|null} Profile data
-   */
-  async getProfile() {
-    if (!this.user) throw new Error('You must login() first.');
-    const { data, error } = await this.supabase.from('profiles').select('*').eq('id', this.user.id).single();
-    if (error) throw error;
-    return data;
-  }
-
-  // ─────────────────────────────────────────────
-  //  SECTION 2: API KEY MANAGEMENT
-  // ─────────────────────────────────────────────
-
-  /**
-   * Set the active API key for storage operations.
-   * @param {string} key - Your BTX-USER-XXXXXXXX key
-   */
-  setApiKey(key) {
-    this.apiKey = key;
-  }
-
-  /**
-   * List all API keys for the logged-in user.
-   * @returns {Array<{label: string, key: string}>}
-   */
-  async getKeys() {
-    if (!this.user) throw new Error('You must login() first.');
-    if (this.provider === 'firebase') {
-      const res = await fetch(`https://firestore.googleapis.com/v1/projects/${this.fbProjectId}/databases/(default)/documents/api_keys`);
-      const data = await res.json();
-      return (data.documents || []).map(d => ({
-        label: d.fields.key_label?.stringValue,
-        key: d.fields.api_key?.stringValue,
-        createdAt: d.createTime
-      }));
-    } else {
-      const { data, error } = await this.supabase.from('api_keys').select('*').eq('user_id', this.user.id);
-      if (error) throw error;
-      return data.map(k => ({ label: k.key_label, key: k.api_key, createdAt: k.created_at }));
-    }
-  }
-
-  /**
-   * Generate a new API key and auto-set it as active.
-   * @param {string} label - A friendly project name
-   * @returns {string} The new API key
-   */
-  async createKey(label) {
-    if (!this.user) throw new Error('You must login() first.');
-    const newKey = `BTX-USER-${_randomId()}`;
-    if (this.provider === 'firebase') {
-      await fetch(`https://firestore.googleapis.com/v1/projects/${this.fbProjectId}/databases/(default)/documents/api_keys?documentId=${newKey}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          fields: {
-            user_id: { stringValue: this.user.id },
-            key_label: { stringValue: label },
-            api_key: { stringValue: newKey }
-          }
-        })
-      });
-    } else {
-      const { error } = await this.supabase.from('api_keys').insert([{
-        user_id: this.user.id,
-        key_label: label,
-        api_key: newKey
-      }]);
-      if (error) throw error;
-    }
-    this.apiKey = newKey;
-    return newKey;
-  }
-
-  /**
-   * Delete a specific API key.
-   * @param {string} apiKey - The key to revoke
-   */
-  async deleteKey(apiKey) {
-    if (!this.user) throw new Error('You must login() first.');
-    const { error } = await this.supabase.from('api_keys').delete().eq('user_id', this.user.id).eq('api_key', apiKey);
-    if (error) throw error;
-    if (this.apiKey === apiKey) this.apiKey = null;
-  }
-
-  /**
-   * Delete a project: removes the API key AND all files uploaded under it.
-   * @param {string} apiKey - The project key to destroy
-   */
-  async deleteProject(apiKey) {
-    const files = await this.listFiles();
-    for (const file of files) {
-      try { await this._workerPost('delete', { fileName: file.file_name }); } catch (e) { /* skip */ }
-    }
-    await this.deleteKey(apiKey);
-  }
-
-  // ─────────────────────────────────────────────
-  //  SECTION 3: FILE UPLOAD
-  // ─────────────────────────────────────────────
-
-  /**
-   * Set the project scope for isolation (e.g., 'development', 'staging', 'production')
-   * @param {string} scope
-   */
-  setProjectScope(scope) {
-    this._projectScope = scope;
+    const { data, error } = await this.supabase.auth.signInWithPassword({ email, password });
+    if (error) throw new Error(`Login Failed: ${error.message}`);
+    this.user = data.user;
+    this._emit('login', this.user);
+    return data.user;
   }
 
-  /**
-   * Register a middleware to intercept uploads and downloads.
-   * @param {object} middleware - Object with beforeUpload / afterUpload methods.
-   */
-  use(middleware) {
-    this._middlewares.push(middleware);
-  }
-
-  /**
-   * Purge the global CDN cache for a specific file.
-   * @param {string} fileName
-   */
-  async purgeCache(fileName) {
-    this._requireKey();
-    const res = await fetch(`${this.workerUrl}?action=purge&key=${this.apiKey}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ fileName })
-    });
-    if (!res.ok) throw new Error('Failed to purge CDN cache');
-    return await res.json();
-  }
-
-  /**
-   * Upload a file with default encryption (AES-CTR).
-   * @param {string} name - Filename (e.g. 'video.mp4')
-   * @param {Blob|ArrayBuffer|File} data - File content
-   * @param {object} [options] - Optional: { thumbnail: Blob, title: string }
-   * @returns {object} { success: boolean }
-   */
-  async upload(name, data, options = {}) {
-    this._requireKey();
-    
-    // Execute beforeUpload Middlewares
-    let payload = { name, data, options, scope: this._projectScope };
-    for (const mw of this._middlewares) {
-      if (typeof mw.beforeUpload === 'function') {
-        payload = await mw.beforeUpload(payload) || payload;
-      }
-    }
-    
-    // Apply scope prefix if not production
-    const finalName = payload.scope !== 'production' ? `[${payload.scope}]_${payload.name}` : payload.name;
-    
-    const fd = new FormData();
-    const blob = payload.data instanceof Blob ? payload.data : new Blob([payload.data]);
-    fd.append('file', blob, finalName);
-    if (options.thumbnail) {
-      const thumbBlob = options.thumbnail instanceof Blob ? options.thumbnail : new Blob([options.thumbnail]);
-      fd.append('thumbnail', thumbBlob, `thumb_${name}`);
-    }
-    if (options.title) fd.append('title', options.title);
-    if (options.password) fd.append('password', options.password);
-
-    const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}`, {
-      method: 'POST',
-      body: fd
-    });
-    if (!res.ok) {
-      const errText = await res.text();
-      this._emit('error', { action: 'upload', message: errText });
-      throw new Error(`Upload failed: ${errText}`);
-    }
-    const result = await res.json();
-    this._emit('upload', { name, size: blob.size });
-    return result;
-  }
-
-  /**
-   * Pro Feature: Chunked Upload for very large files.
-   * Splits file into 5MB chunks for better reliability.
-   * @param {string} name 
-   * @param {File|Blob} file 
-   * @param {object} [options] 
-   */
-  async uploadLarge(name, file, options = {}) {
-    this._requireKey();
-    const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB
-    const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
-    
-    console.log(`[ByteX] 🚀 Starting Chunked Upload for ${name} (${totalChunks} chunks)`);
-    
-    // For now, we perform a simplified sequential upload or a single multi-part
-    // In a full TUS implementation, we would send chunks one by one.
-    // For ByteX, we will use the standard upload but with optimized buffer handling.
-    return this.upload(name, file, options);
-  }
-
-
-  /**
-   * Upload a file WITHOUT encryption (raw/plain).
-   * Note: This sends the file directly without AES-CTR processing.
-   * The file will still be committed to your storage node as-is.
-   * @param {string} name 
-   * @param {Blob|ArrayBuffer|File} data 
-   * @returns {object}
-   */
-  async uploadRaw(name, data) {
+  async upload(name, data) {
     this._requireKey();
     const fd = new FormData();
     const blob = data instanceof Blob ? data : new Blob([data]);
     fd.append('file', blob, name);
-    fd.append('raw', 'true');
-
-    const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}&raw=true`, {
-      method: 'POST',
-      body: fd
-    });
-    if (!res.ok) throw new Error(`Raw upload failed: ${await res.text()}`);
-    return await res.json();
-  }
 
-  /**
-   * Upload a file with a CUSTOM encryption key (Bring Your Own Key).
-   * @param {string} name 
-   * @param {Blob|ArrayBuffer|File} data 
-   * @param {string} encryptionKey - Your custom 32-char encryption key
-   * @returns {object}
-   */
-  async uploadEncrypted(name, data, encryptionKey) {
-    this._requireKey();
-    const rawData = data instanceof Blob ? await data.arrayBuffer() : (data instanceof ArrayBuffer ? data : new Blob([data]).arrayBuffer());
-    const actualData = rawData instanceof Promise ? await rawData : rawData;
-    const encrypted = await this.encrypt(actualData, encryptionKey);
-    const fd = new FormData();
-    fd.append('file', new Blob([encrypted]), name);
-    fd.append('custom_enc', 'true');
-
-    const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}&custom_enc=true`, {
+    const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}`, {
       method: 'POST',
       body: fd
     });
-    if (!res.ok) throw new Error(`Encrypted upload failed: ${await res.text()}`);
+    if (!res.ok) throw new Error(`Upload failed: ${await res.text()}`);
     return await res.json();
   }
 
-  // ─────────────────────────────────────────────
-  //  SECTION 4: FILE RETRIEVAL & STREAMING
-  // ─────────────────────────────────────────────
-
-  /**
-   * Download a file (auto-decrypts if encrypted).
-   * @param {string} name - Filename (with or without .stream.btx)
-   * @param {string} [password] - Password if the file is protected
-   * @returns {Blob} Decrypted file data
-   */
-  async download(name, password) {
+  async downloadData(name) {
     this._requireKey();
-    // ByteX Worker always expects .stream.btx for action=view
     const streamName = name.endsWith('.stream.btx') ? name : `${name}.stream.btx`;
-    let url = `${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(streamName)}`;
-    if (password) url += `&password=${encodeURIComponent(password)}`;
+    const url = `${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(streamName)}&_cb=${Date.now()}`;
     
     const { data: { session } } = await this.supabase.auth.getSession();
     const res = await fetch(url, {
       headers: {
-        'Authorization': `Bearer ${session?.access_token || ''}`
+        'Authorization': `Bearer ${session?.access_token || ''}`,
+        'Cache-Control': 'no-cache'
       }
     });
     if (!res.ok) throw new Error(`Download failed: ${res.status}`);
-    return await res.blob();
-  }
-
-  /**
-   * Helper to download JSON data directly from cloud.
-   * @param {string} name 
-   * @returns {object}
-   */
-  async downloadData(name) {
-    const blob = await this.download(name);
-    const text = await blob.text();
-    return JSON.parse(text);
+    const text = await res.text();
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      // Handle NDJSON
+      return text.split('\n').filter(Boolean).map(line => JSON.parse(line));
+    }
   }
 
-  /**
-   * Get the streaming URL for a media file (video/audio).
-   * Supports precision seeking with range requests.
-   * @param {string} name - Original filename (e.g. 'movie.mp4')
-   * @param {string} [password] - Password if the file is protected
-   * @returns {string} Full streaming URL
-   */
-  stream(name, password) {
+  async delete(name) {
     this._requireKey();
     const streamName = name.endsWith('.stream.btx') ? name : `${name}.stream.btx`;
-    let url = `${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(streamName)}`;
-    if (password) url += `&password=${encodeURIComponent(password)}`;
-    return url;
+    const { data: { session } } = await this.supabase.auth.getSession();
+    const res = await fetch(`${this.workerUrl}?action=delete&key=${this.apiKey}&file=${encodeURIComponent(streamName)}`, {
+      method: 'DELETE',
+      headers: {
+        'Authorization': `Bearer ${session?.access_token || ''}`
+      }
+    });
+    if (!res.ok) throw new Error(`Delete failed: ${res.status}`);
+    return { success: true };
   }
 
-  // ─────────────────────────────────────────────
-  //  SECTION 5: FILE MANAGEMENT
-  // ─────────────────────────────────────────────
-
-  /**
-   * List all uploaded files with metadata.
-   * @returns {Array<{file_name, path, title, thumbnail, size, uploaded_at}>}
-   */
   async listFiles() {
     this._requireKey();
     const res = await fetch(`${this.workerUrl}?action=list&key=${this.apiKey}&cb=${Date.now()}`);
     if (!res.ok) throw new Error(`List failed: ${res.status}`);
     const text = await res.text();
-    if (!text || text.trim() === '' || text.trim() === '{}') return [];
-    return text.trim().split('\n').filter(l => l.trim() !== '' && l.trim() !== '{}').map(line => {
-      try { return JSON.parse(line); } catch (e) { return null; }
-    }).filter(Boolean);
-  }
-
-  /**
-   * Get detailed info/metadata for a specific file.
-   * @param {string} name - The filename to look up
-   * @returns {object|null} File metadata or null
-   */
-  async getFileInfo(name) {
-    const files = await this.listFiles();
-    const baseName = name.replace(/\.stream\.btx$/i, '').replace(/\.btx$/i, '');
-    return files.find(f => {
-      const fBase = (f.file_name || f.path || '').replace(/\.stream\.btx$/i, '').replace(/\.btx$/i, '');
-      return fBase === baseName || fBase === name;
-    }) || null;
-  }
-
-  /**
-   * Search files by name or title.
-   * @param {string} query - Search query (case-insensitive)
-   * @returns {Array} Matching files
-   */
-  async search(query) {
-    const files = await this.listFiles();
-    const q = query.toLowerCase();
-    return files.filter(f =>
-      (f.file_name || '').toLowerCase().includes(q) ||
-      (f.title || '').toLowerCase().includes(q)
-    );
-  }
-
-  /**
-   * Delete a single file permanently.
-   * @param {string} name - Filename to delete
-   * @returns {object} { success: boolean }
-   */
-  async delete(name) {
-    this._requireKey();
-    const streamName = name.endsWith('.stream.btx') ? name : `${name}.stream.btx`;
-    const result = await this._workerPost('delete', { fileName: streamName });
-    this._emit('delete', { name });
-    return result;
+    return text.split('\n').filter(Boolean).map(line => JSON.parse(line));
   }
 
   /**
-   * Delete ALL files in your storage. Use with caution!
-   * @returns {{ deleted: number, errors: number }}
-   */
-  async deleteAll() {
-    const files = await this.listFiles();
-    let deleted = 0, errors = 0;
-    for (const file of files) {
-      try {
-        await this._workerPost('delete', { fileName: file.file_name || file.path });
-        deleted++;
-      } catch (e) { errors++; }
-    }
-    return { deleted, errors };
-  }
-
-  /**
-   * Rename a file (delete old + re-upload metadata).
-   * @param {string} oldName 
-   * @param {string} newName 
-   */
-  async rename(oldName, newName) {
-    this._requireKey();
-    const fileData = await this.download(oldName);
-    await this.delete(oldName);
-    await this.upload(newName, fileData);
-  }
-
-  // ─────────────────────────────────────────────
-  //  SECTION 6: BULK & EXPORT OPERATIONS
-  // ─────────────────────────────────────────────
-
-  /**
-   * Download ALL files and return as a map of { filename: Blob }.
-   * For ZIP export in browser, use exportZip() instead.
-   * @returns {Object<string, Blob>}
-   */
-  async downloadAll() {
-    const files = await this.listFiles();
-    const result = {};
-    for (const file of files) {
-      try {
-        const blob = await this.download(file.file_name || file.path);
-        const cleanName = (file.file_name || file.path || 'file').replace(/\.stream\.btx$/i, '');
-        result[cleanName] = blob;
-      } catch (e) { /* skip failed downloads */ }
-    }
-    return result;
-  }
-
-  /**
-   * Export ALL files as a single ZIP download (browser only).
-   * Requires JSZip to be available globally or passed in options.
-   * @param {object} [options] - { JSZip: JSZipConstructor, zipName: 'bytex-export.zip' }
-   * @returns {Blob} ZIP file blob
-   */
-  /**
-   * Export files as a single ZIP download (browser only).
-   * @param {object} [options] - { projectLabel, JSZip, zipName }
-   * @returns {Blob} ZIP file blob
+   * ByteX X-RAY: Full system diagnostic.
    */
-  async exportZip(options = {}) {
-    const JSZipLib = options.JSZip || (typeof globalThis !== 'undefined' && globalThis.JSZip);
-    if (!JSZipLib) throw new Error('exportZip requires JSZip.');
-    
-    const zip = new JSZipLib();
-    const files = await this.listFiles();
-    
-    // Filter by project label if provided
-    const filteredFiles = options.projectLabel 
-      ? files.filter(f => f.key_label === options.projectLabel)
-      : files;
+  async xray() {
+    console.log('[ByteX X-RAY] 🔍 Starting diagnostic scan...');
+    const report = {
+      timestamp: new Date().toISOString(),
+      sdk_version: '1.8.1',
+      checks: {}
+    };
 
-    for (const file of filteredFiles) {
-      try {
-        const blob = await this.download(file.file_name || file.path);
-        const name = (file.file_name || file.path || 'file').replace(/\.stream\.btx$/i, '');
-        zip.file(name, blob);
-      } catch (e) { console.warn(`Failed to include ${file.file_name} in ZIP`); }
+    try {
+      this._requireKey();
+      report.checks.api_key = { status: 'OK', key: `${this.apiKey.substring(0, 8)}...` };
+    } catch (e) {
+      report.checks.api_key = { status: 'ERROR', message: e.message };
     }
-    
-    const zipBlob = await zip.generateAsync({ type: 'blob' });
-    
-    if (typeof document !== 'undefined') {
-      const a = document.createElement('a');
-      a.href = URL.createObjectURL(zipBlob);
-      a.download = options.zipName || (options.projectLabel ? `bytex-${options.projectLabel}.zip` : 'bytex-export.zip');
-      a.click();
-      URL.revokeObjectURL(a.href);
-    }
-    return zipBlob;
-  }
 
-  // ─────────────────────────────────────────────
-  //  SECTION 7: QUOTA & MONITORING
-  // ─────────────────────────────────────────────
-
-  /**
-   * Get current storage usage and limits.
-   * @returns {{ usedBytes, limitBytes, usedGB, limitGB, percentage }}
-   */
-  async getQuota() {
-    this._requireKey();
-    const res = await fetch(`${this.workerUrl}?action=quota`, {
-      headers: { 'x-bytex-key': this.apiKey }
-    });
-    if (!res.ok) throw new Error(`Quota check failed: ${res.status}`);
-    const data = await res.json();
-    const usedGB = (data.usedBytes / (1024 ** 3)).toFixed(2);
-    const limitGB = data.limitBytes > 0 ? (data.limitBytes / (1024 ** 3)).toFixed(0) : 'Unlimited';
-    const percentage = data.limitBytes > 0 ? ((data.usedBytes / data.limitBytes) * 100).toFixed(1) : 0;
-
-    if (percentage > 90) this._emit('quota-warn', { percentage, usedGB, limitGB });
-
-    return { ...data, usedGB, limitGB, percentage };
-  }
-
-  /**
-   * Get detailed analytics for the current API Key.
-   * @returns {Promise<{download_count, bandwidth_used_gb}>}
-   */
-  async getAnalytics() {
-    this._requireKey();
-    const { data, error } = await this.supabase
-      .from('api_keys')
-      .select('download_count, bandwidth_used')
-      .eq('api_key', this.apiKey)
-      .single();
-    
-    if (error) throw error;
-    return {
-      downloadCount: data.download_count || 0,
-      bandwidthUsedGB: ((data.bandwidth_used || 0) / (1024 ** 3)).toFixed(4)
+    const { data: { session } } = await this.supabase.auth.getSession();
+    report.checks.auth = {
+      status: session ? 'LOGGED_IN' : 'GUEST',
+      user: session?.user?.email || 'none'
     };
-  }
-
 
-  // ─────────────────────────────────────────────
-  //  SECTION 8: ENCRYPTION UTILITIES
-  // ─────────────────────────────────────────────
-
-  /**
-   * Encrypt raw data using AES-CTR.
-   * @param {ArrayBuffer} data - Raw data to encrypt
-   * @param {string} [key] - 32-char encryption key (defaults to ByteX standard)
-   * @returns {ArrayBuffer} Encrypted data
-   */
-  async encrypt(data, key) {
-    const encoder = new TextEncoder();
-    const kb = encoder.encode(key || DEFAULT_ENC_KEY).slice(0, 32);
-    const iv = encoder.encode(DEFAULT_IV).slice(0, 16);
-    const cryptoKey = await crypto.subtle.importKey('raw', kb, 'AES-CTR', false, ['encrypt']);
-    return await crypto.subtle.encrypt({ name: 'AES-CTR', counter: iv, length: 64 }, cryptoKey, data);
-  }
-
-  /**
-   * Decrypt AES-CTR encrypted data.
-   * @param {ArrayBuffer} data - Encrypted data
-   * @param {string} [key] - 32-char encryption key (defaults to ByteX standard)
-   * @returns {ArrayBuffer} Decrypted data
-   */
-  async decrypt(data, key) {
-    const encoder = new TextEncoder();
-    const kb = encoder.encode(key || DEFAULT_ENC_KEY).slice(0, 32);
-    const iv = encoder.encode(DEFAULT_IV).slice(0, 16);
-    const cryptoKey = await crypto.subtle.importKey('raw', kb, 'AES-CTR', false, ['decrypt']);
-    return await crypto.subtle.decrypt({ name: 'AES-CTR', counter: iv, length: 64 }, cryptoKey, data);
-  }
-
-  // ─────────────────────────────────────────────
-  //  SECTION 9: SHARING
-  // ─────────────────────────────────────────────
-
-  /**
-   * Generate a public shareable URL for a file.
-   * @param {string} name - Filename to share
-   * @param {string} [password] - Optional password protection
-   * @returns {string} Public URL
-   */
-  share(name, password) {
-    return this.stream(name, password);
-  }
+    const start = Date.now();
+    try {
+      const res = await fetch(`${this.workerUrl}?action=list&key=${this.apiKey}`);
+      report.checks.worker = {
+        status: res.ok ? 'ONLINE' : 'ERROR',
+        latency_ms: Date.now() - start
+      };
+    } catch (e) {
+      report.checks.worker = { status: 'OFFLINE', message: e.message };
+    }
 
-  /**
-   * Generate a time-limited signed URL.
-   * @param {string} name - Filename to share
-   * @param {string} duration - Duration string (e.g. '1h', '2d')
-   * @param {string} [password] - Optional password
-   * @returns {Promise<string>} Signed URL
-   */
-  async shareSigned(name, duration, password) {
-    this._requireKey();
-    const streamName = name.endsWith('.stream.btx') ? name : `${name}.stream.btx`;
+    const issues = Object.values(report.checks).filter(c => c.status === 'ERROR' || c.status === 'OFFLINE');
+    report.health_score = issues.length === 0 ? 'EXCELLENT' : 'CRITICAL';
     
-    // Parse duration (very basic)
-    let ms = 3600000; // default 1h
-    if (duration.endsWith('h')) ms = parseInt(duration) * 3600000;
-    else if (duration.endsWith('d')) ms = parseInt(duration) * 86400000;
-    else if (duration.endsWith('m')) ms = parseInt(duration) * 60000;
-    
-    const expires = Date.now() + ms;
-    const secret = "btx-link-signing-secret"; // Must match worker secret
-    
-    // Generate HMAC signature
-    const encoder = new TextEncoder();
-    const data = encoder.encode(`${streamName}:${expires}`);
-    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const signatureBuffer = await crypto.subtle.sign("HMAC", key, data);
-    const signature = Array.from(new Uint8Array(signatureBuffer)).map(b => b.toString(16).padStart(2, "0")).join("");
-
-    let url = `${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(streamName)}&expires=${expires}&signature=${signature}`;
-    if (password) url += `&password=${encodeURIComponent(password)}`;
-    return url;
+    return report;
   }
 
-  // ─────────────────────────────────────────────
-  //  SECTION 10: EVENT SYSTEM
-  // ─────────────────────────────────────────────
-
-  /**
-   * Listen to SDK events.
-   * Supported events: 'login', 'logout', 'upload', 'delete', 'error', 'quota-warn'
-   * @param {string} event 
-   * @param {Function} callback 
-   */
-  on(event, callback) {
-    if (!this._listeners[event]) this._listeners[event] = [];
-    this._listeners[event].push(callback);
-  }
-
-  /**
-   * Remove an event listener.
-   * @param {string} event 
-   * @param {Function} callback 
-   */
-  off(event, callback) {
-    if (!this._listeners[event]) return;
-    this._listeners[event] = this._listeners[event].filter(cb => cb !== callback);
-  }
-
-  // ─────────────────────────────────────────────
-  //  INTERNAL HELPERS
-  // ─────────────────────────────────────────────
-
   _requireKey() {
-    if (!this.apiKey) throw new Error('API Key required! Call setApiKey() or createKey() first.');
+    if (!this.apiKey) throw new Error('API Key required!');
   }
 
   _emit(event, data) {
     if (this._listeners[event]) {
-      this._listeners[event].forEach(cb => { try { cb(data); } catch (e) {} });
+      this._listeners[event].forEach(cb => cb(data));
     }
   }
 
-  async _workerPost(action, body) {
-    const res = await fetch(`${this.workerUrl}?action=${action}&key=${this.apiKey}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const errText = await res.text();
-      this._emit('error', { action, message: errText });
-      throw new Error(`${action} failed: ${errText}`);
-    }
-    return await res.json();
-  }
-}
-
-/**
- * BytexWeb — Manage and deploy websites to Cloudflare Pages.
- */
-export class BytexWeb {
-  constructor(config = {}) {
-    this.cfToken = config.cfToken || null;
-    this.cfAccountId = config.cfAccountId || null;
-  }
-
-  /**
-   * Deploy a static directory to Cloudflare Pages.
-   * @param {string} projectName 
-   * @param {string} directory - Path to build files
-   * @returns {Promise<object>} Deployment info
-   */
-  async deploy(projectName, directory) {
-    if (!this.cfToken || !this.cfAccountId) throw new Error('Cloudflare credentials required.');
-    
-    // 1. Create project if not exists
-    await fetch(`https://api.cloudflare.com/client/v4/accounts/${this.cfAccountId}/pages/projects`, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${this.cfToken}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: projectName, production_branch: 'main' })
-    }).catch(() => {}); // ignore error if already exists
-
-    // 2. Deployment via direct upload requires zipping or multipart
-    // For the SDK (browser/node), we'll provide the instructions or use a helper.
-    // In the CLI, we will use a more robust method.
-    return { success: true, url: `https://${projectName}.pages.dev` };
-  }
-
-  /**
-   * Bind a custom domain to a Pages project.
-   * @param {string} projectName 
-   * @param {string} domain 
-   */
-  async addDomain(projectName, domain) {
-    const res = await fetch(`https://api.cloudflare.com/client/v4/accounts/${this.cfAccountId}/pages/projects/${projectName}/domains`, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${this.cfToken}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: domain })
-    });
-    return await res.json();
+  on(event, callback) {
+    if (!this._listeners[event]) this._listeners[event] = [];
+    this._listeners[event].push(callback);
   }
 }
-
-export const BytexMiddlewares = {
-  /**
-   * Middleware to automatically optimize images to WebP in the browser before upload.
-   * @param {number} quality - WebP quality (0.0 to 1.0)
-   */
-  imageOptimizer: (quality = 0.8) => ({
-    beforeUpload: async (payload) => {
-      // Only run in browser environment and if the file is an image
-      if (typeof document === 'undefined' || !payload.name.match(/\.(jpg|jpeg|png)$/i)) return payload;
-      
-      try {
-        const file = payload.data;
-        const bitmap = await createImageBitmap(file);
-        const canvas = document.createElement('canvas');
-        canvas.width = bitmap.width;
-        canvas.height = bitmap.height;
-        const ctx = canvas.getContext('2d');
-        ctx.drawImage(bitmap, 0, 0);
-        
-        const optimizedBlob = await new Promise(resolve => canvas.toBlob(resolve, 'image/webp', quality));
-        payload.data = optimizedBlob;
-        payload.name = payload.name.replace(/\.(jpg|jpeg|png)$/i, '.webp');
-        console.log(`[ByteX SDK] Optimized image to WebP: ${payload.name}`);
-      } catch (e) {
-        console.warn('[ByteX SDK] Image optimization failed, skipping:', e);
-      }
-      return payload;
-    }
-  })
-};
-
-function _randomId() {
-  return Math.random().toString(36).substring(2, 10).toUpperCase();
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bytex-sdk",
-  "version": "1.7.6",
+  "version": "1.8.1",
   "description": "",
   "main": "index.js",
   "scripts": {