bytex-sdk 1.3.0 → 1.5.0

package/README.md

@@ -0,0 +1,56 @@
+# ByteX SDK ⚡
+> The official SDK for the ByteX Cloud Ecosystem.
+
+ByteX SDK provides a powerful, easy-to-use interface for interacting with ByteX Cloud storage and infrastructure. It supports both Supabase and Firebase backends, enabling a true "Bring Your Own Cloud" (BYOC) experience.
+
+## ✨ Features
+- **Multi-Provider**: Seamlessly switch between Supabase and Firebase.
+- **Advanced Encryption**: Built-in AES-CTR encryption for secure file storage.
+- **Streaming Support**: Direct streaming for media files (video/audio).
+- **CDN Integration**: Purge and manage global CDN cache.
+- **Middleware System**: Intercept and optimize uploads (e.g., auto-convert to WebP).
+- **Bulk Operations**: Download or export entire projects as ZIP.
+
+## 📦 Installation
+```bash
+npm install bytex-sdk
+```
+
+## 🚀 Quick Start
+```javascript
+import { BytexCloud } from 'bytex-sdk';
+
+// Initialize with your API Key
+const bytex = new BytexCloud({ 
+  apiKey: 'BTX-USER-XXXXXXXX',
+  dbProvider: 'supabase' // or 'firebase'
+});
+
+// Upload a file
+await bytex.upload('hello.txt', 'Hello World');
+
+// Get a streaming URL
+const streamUrl = bytex.stream('video.mp4');
+
+// List files
+const files = await bytex.listFiles();
+console.log(files);
+```
+
+## 🛠 Advanced Usage: Middleware
+```javascript
+import { BytexCloud, BytexMiddlewares } from 'bytex-sdk';
+
+const bytex = new BytexCloud({ apiKey: '...' });
+
+// Automatically optimize images to WebP before upload
+bytex.use(BytexMiddlewares.imageOptimizer(0.8));
+
+await bytex.upload('photo.jpg', fileData); // Uploads as photo.webp
+```
+
+## 🛡 Security
+All storage operations are authenticated via API keys. Data can be encrypted locally using standard or custom encryption keys, ensuring that your storage provider never sees raw data.
+
+## 📄 License
+ISC © ByteX Ecosystem

package/index.js

@@ -1,79 +1,704 @@
 import { createClient } from '@supabase/supabase-js';
 
 const SUPABASE_URL = 'https://vkiddclfbwmslaiyyftl.supabase.co';
-const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdWJhYmFzZSIsInJlZiI6InZraWRkY2xmYndtc2xhaXl5ZnRsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDY3NzEyOTYsImV4cCI6MjA2MjM0NzI5Nn0.V_l_b6WptKoxCko-vRQ5yPIBliOxNaxcRmqezSs';
+const SUPABASE_ANON_KEY = 'sb_publishable_hXMlH9OmJG1_n1s-3lbXKg_6V-88Lj9';
+const WORKER_URL = 'https://api.server-bytex.workers.dev/';
+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;
-    this.supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+    this.workerUrl = config.workerUrl || WORKER_URL;
+    this.provider = config.dbProvider || 'supabase';
+    
+    if (this.provider === 'supabase') {
+      const url = config.supabaseUrl || SUPABASE_URL;
+      const key = config.supabaseKey || SUPABASE_ANON_KEY;
+      this.supabase = createClient(url, key);
+    } else if (this.provider === 'firebase') {
+      this.fbProjectId = config.fbProjectId;
+      this.fbApiKey = config.fbApiKey;
+    }
+
     this.user = null;
-    console.log(`🚀 ByteX SDK Initialized!`);
+    this._listeners = {};
+    this._middlewares = [];
+    this._projectScope = 'production';
   }
 
-  // Auth: Log in using ByteX Email & Password
+  // ─────────────────────────────────────────────
+  //  SECTION 1: AUTHENTICATION
+  // ─────────────────────────────────────────────
+
   async login(email, password) {
-    const { data, error } = await this.supabase.auth.signInWithPassword({ email, password });
-    if (error) throw new Error(`Login Failed: ${error.message}`);
-    this.user = data.user;
-    return this.user;
+    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;
+    }
   }
 
-  // Keys: Get all API keys for the logged-in user
-  async getKeys() {
-    if (!this.user) throw new Error("You must login() first.");
-    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 }));
-  }
-
-  // Keys: Create a new API key and set it as active
-  async createKey(projectName) {
-    if (!this.user) throw new Error("You must login() first.");
-    const newKey = `BTX-${Math.random().toString(36).substring(2,12).toUpperCase()}`;
-    const { error } = await this.supabase.from('api_keys').insert([{ 
-      user_id: this.user.id, 
-      key_label: projectName, 
-      api_key: newKey 
-    }]);
-    
+  /**
+   * 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;
-    this.apiKey = newKey; // Auto-set the active key
-    return newKey;
+    return data;
   }
 
-  // Storage: Set API Key manually
+  // ─────────────────────────────────────────────
+  //  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;
   }
 
-  // Storage: Upload file (Requires API Key)
-  async upload(name, data) {
-    if (!this.apiKey) throw new Error("API Key Required! Provide one in constructor or call createKey().");
-    console.log(`[ByteX] 📤 Uploading ${name} using Key: ${this.apiKey}...`);
-    return { success: true, url: `https://bytex.work/v1/${name}` };
+  /**
+   * 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;
+  }
+
+  /**
+   * 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) {
+    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`, {
+      method: 'POST',
+      body: fd
+    });
+    if (!res.ok) throw new Error(`Encrypted 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) {
+    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)}`;
+    
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+    return await res.blob();
+  }
+
+  /**
+   * 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) {
+    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;
+  }
+
+  // ─────────────────────────────────────────────
+  //  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;
   }
 
-  // Storage: Download file
-  async download(name) {
-    if (!this.apiKey) throw new Error("API Key Required!");
-    console.log(`[ByteX] 📥 Downloading ${name} from Cloud...`);
-    // Mock return file buffer
-    return { success: true, data: new Blob() };
+  /**
+   * 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)
+    );
   }
 
-  // Storage: Delete file
+  /**
+   * Delete a single file permanently.
+   * @param {string} name - Filename to delete
+   * @returns {object} { success: boolean }
+   */
   async delete(name) {
-    if (!this.apiKey) throw new Error("API Key Required!");
-    console.log(`[ByteX] 🗑️  Removing ${name} from Cloud...`);
-    return { success: true };
+    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;
   }
 
-  // Storage: Rename file
+  /**
+   * 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) {
-    if (!this.apiKey) throw new Error("API Key Required!");
-    console.log(`[ByteX] ✏️  Renaming ${oldName} to ${newName}...`);
-    return { success: true };
+    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
+   */
+  async exportZip(options = {}) {
+    const JSZipLib = options.JSZip || (typeof globalThis !== 'undefined' && globalThis.JSZip);
+    if (!JSZipLib) throw new Error('exportZip requires JSZip. Install it: npm install jszip');
+    
+    const zip = new JSZipLib();
+    const allFiles = await this.downloadAll();
+    for (const [name, blob] of Object.entries(allFiles)) {
+      zip.file(name, blob);
+    }
+    const zipBlob = await zip.generateAsync({ type: 'blob' });
+    
+    // Auto-download in browser
+    if (typeof document !== 'undefined') {
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(zipBlob);
+      a.download = options.zipName || '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)
+    };
+  }
+
+
+  // ─────────────────────────────────────────────
+  //  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);
+  }
+
+  /**
+   * 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`;
+    
+    // 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;
+  }
+
+  // ─────────────────────────────────────────────
+  //  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.');
+  }
+
+  _emit(event, data) {
+    if (this._listeners[event]) {
+      this._listeners[event].forEach(cb => { try { cb(data); } catch (e) {} });
+    }
+  }
+
+  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();
   }
 }
 
+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.3.0",
+  "version": "1.5.0",
   "description": "",
   "main": "index.js",
   "scripts": {