bytex-sdk 5.5.0 → 5.7.0

package/README.md

@@ -1,56 +1,45 @@
-# ByteX SDK ⚡
-> The official SDK for the ByteX Cloud Ecosystem.
+# ByteX Cloud SDK 🚀
 
-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.
+The official SDK for the ByteX ecosystem, enabling developers to build professional "Super SaaS" products with 100% cloud sovereignty (BYOC).
 
-## ✨ 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.
+## Features
+- 🔐 **Secure Authentication**: Integrated with Supabase.
+- 📦 **Data Persistence**: Upload and download streams directly to your own Cloud (HuggingFace).
+- 🕵️‍♂️ **X-Ray Diagnostics**: Built-in network and infrastructure health checks.
+- ⚡ **Lightweight**: Zero-config needed for most use cases.
 
-## 📦 Installation
+## Installation
 ```bash
-npm install bytex-sdk
+npm install @bytex/cloud-sdk
 ```
 
-## 🚀 Quick Start
+## Quick Start
+
+### Initialize
 ```javascript
-import { BytexCloud } from 'bytex-sdk';
+import { BytexCloud } from '@bytex/cloud-sdk';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
-// Initialize with your API Key
-const bytex = new BytexCloud({ 
-  apiKey: 'BTX-USER-XXXXXXXX',
-  dbProvider: 'supabase' // or 'firebase'
+const bytex = new BytexCloud({
+  apiKey: 'YOUR_API_KEY',
+  workerUrl: 'https://api.bytex.work/',
+  storage: AsyncStorage // for React Native
 });
-
-// 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
+### Upload Data
 ```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
+await bytex.uploadData('my_project', { 
+  status: 'active', 
+  users: 1000 
+});
 ```
 
-## 🛡 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.
+### Infrastructure Health Check (X-Ray)
+```javascript
+const report = await bytex.xray();
+console.log(report.checks);
+```
 
-## 📄 License
-ISC © ByteX Ecosystem
+## License
+MIT © ByteX Guru

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "bytex-sdk",
-  "version": "5.5.0",
-  "description": "Official ByteX Cloud SDK with AI (BYOM) support",
-  "main": "index.js",
+  "version": "5.7.0",
+  "description": "The official ByteX Cloud SDK for BYOC (Bring Your Own Cloud) infrastructure management.",
+  "main": "src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "postinstall": "node postinstall.js"
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "keywords": [
+    "bytex",
+    "cloud",
+    "saas",
+    "byoc",
+    "supabase",
+    "huggingface"
+  ],
+  "author": "ByteX Guru",
+  "license": "MIT",
   "dependencies": {
-    "@supabase/supabase-js": "^2.105.4",
-    "chalk": "^5.3.0"
-  },
-  "keywords": ["bytex", "cloud", "storage", "ai", "byom", "byoc"],
-  "author": "ByteX Team",
-  "license": "ISC",
-  "type": "module"
+    "@supabase/supabase-js": "^2.39.0",
+    "react-native-url-polyfill": "^2.0.0"
+  }
 }

package/src/index.js

@@ -0,0 +1,183 @@
+import { createClient } from '@supabase/supabase-js';
+
+const SUPABASE_URL = 'https://vkiddclfbwmslaiyyftl.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZraWRkY2xmYndtc2xhaXl5ZnRsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzgzMDYyNjMsImV4cCI6MjA5Mzg4MjI2M30.VMtzB_I_b6WptKoxCko-vRQ5yPIBliOxNaxcRmqezSs';
+const WORKER_URL = 'https://api.bytex.work/';
+
+export class BytexCloud {
+  constructor(config = {}) {
+    this.config = config;
+    this.apiKey = config.apiKey || null;
+    this.workerUrl = config.workerUrl || WORKER_URL;
+    
+    const supabaseConfig = {
+      auth: {
+        persistSession: true,
+        autoRefreshToken: true,
+        detectSessionInUrl: false
+      }
+    };
+    if (config.storage) {
+      supabaseConfig.auth.storage = config.storage;
+    }
+    
+    this.supabase = createClient(
+      config.supabaseUrl || SUPABASE_URL, 
+      config.supabaseKey || SUPABASE_ANON_KEY, 
+      supabaseConfig
+    );
+    this._listeners = {};
+  }
+
+  async _execute(fn, action) {
+    try {
+      return await fn();
+    } catch (e) {
+      const diag = await this.xray();
+      const advice = diag.advice.length > 0 ? `\n[X-RAY Advice]: ${diag.advice.join(' ')}` : '';
+      throw new Error(`${action} failed: ${e.message}${advice}`);
+    }
+  }
+
+  async login(email, password) {
+    return this._execute(async () => {
+      const { data, error } = await this.supabase.auth.signInWithPassword({ email, password });
+      if (error) throw error;
+      return data.user;
+    }, 'Login');
+  }
+
+  async register(email, password) {
+    return this._execute(async () => {
+      const { data, error } = await this.supabase.auth.signUp({ email, password });
+      if (error) throw error;
+      return data.user;
+    }, 'Register');
+  }
+
+  async logout() {
+    await this.supabase.auth.signOut();
+  }
+
+  async getUser() {
+    const { data: { session } } = await this.supabase.auth.getSession();
+    return session?.user || null;
+  }
+
+  async upload(name, data) {
+    return this._execute(async () => {
+      this._requireKey();
+      const fd = new FormData();
+      if (data && typeof data === 'object' && data.uri) {
+        // React Native specific FormData file upload
+        const rnFile = {
+          uri: data.uri,
+          name: name, // Enforce full folder path
+          type: data.type || 'audio/mpeg'
+        };
+        fd.append('file', rnFile);
+      } else {
+        fd.append('file', data instanceof Blob ? data : new Blob([data]), name);
+      }
+      const { data: { session } } = await this.supabase.auth.getSession();
+      const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}&file=${encodeURIComponent(name)}`, { 
+        method: 'POST', 
+        headers: { 'Authorization': `Bearer ${session?.access_token || ''}` },
+        body: fd 
+      });
+      if (!res.ok) throw new Error(await res.text() || res.statusText);
+      return await res.json();
+    }, 'Upload');
+  }
+
+  async uploadData(name, data) {
+    return this._execute(async () => {
+      this._requireKey();
+      const streamName = name.endsWith('.btx') ? name : `${name}.stream.btx`;
+      const url = `${this.workerUrl}?action=upload&key=${this.apiKey}&file=${encodeURIComponent(streamName)}`;
+      const { data: { session } } = await this.supabase.auth.getSession();
+      
+      const payload = typeof data === 'string' ? data : JSON.stringify(data);
+      
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 
+          'Authorization': `Bearer ${session?.access_token || ''}`,
+          'Content-Type': 'application/json'
+        },
+        body: payload
+      });
+      
+      if (!res.ok) throw new Error(`Upload failed with status ${res.status}`);
+      return await res.json();
+    }, 'Upload');
+  }
+
+  async downloadData(name) {
+    return this._execute(async () => {
+      this._requireKey();
+      const streamName = name.endsWith('.btx') ? name : `${name}.stream.btx`;
+      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 || ''}` }
+      });
+      if (!res.ok) throw new Error(`Status ${res.status}`);
+      const text = await res.text();
+      try { return JSON.parse(text); } catch (e) { return text.split('\n').filter(Boolean).map(line => JSON.parse(line)); }
+    }, 'Download');
+  }
+
+  getStreamUrl(name) {
+    const streamName = name.endsWith('.btx') ? name : (name.endsWith('.stream.btx') ? name : `${name}.stream.btx`);
+    return `${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(streamName)}`;
+  }
+
+  async download(name) {
+    return this._execute(async () => {
+      this._requireKey();
+      const url = this.getStreamUrl(name);
+      const { data: { session } } = await this.supabase.auth.getSession();
+      const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${session?.access_token || ''}` }
+      });
+      if (!res.ok) throw new Error(`Status ${res.status}`);
+      return await res.blob();
+    }, 'Download');
+  }
+
+  async delete(name) {
+    return this._execute(async () => {
+      this._requireKey();
+      const streamName = name.endsWith('.btx') ? name : `${name}.stream.btx`;
+      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(`Status ${res.status}`);
+      return true;
+    }, 'Delete');
+  }
+
+  async xray() {
+    const report = { timestamp: new Date().toISOString(), checks: {}, advice: [] };
+    const { data: { session } } = await this.supabase.auth.getSession();
+    
+    try {
+      const res = await fetch(`${this.workerUrl}?action=list&key=${this.apiKey}`);
+      report.checks.connectivity = res.ok ? 'OK' : 'ERROR';
+    } catch (e) {
+      report.checks.connectivity = 'OFFLINE';
+      report.advice.push('ByteX Cloud unreachable. Check internet connection.');
+    }
+
+    if (!this.apiKey) report.advice.push('API Key is missing.');
+    if (!session) report.advice.push('User is not logged in.');
+    if (!this.config.storage) report.advice.push('AsyncStorage engine is missing.');
+
+    return report;
+  }
+
+  _requireKey() { if (!this.apiKey) throw new Error('API Key required!'); }
+}

package/index.js

@@ -1,930 +0,0 @@
-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/';
-
-export class BytexCloud {
-  constructor(config = {}) {
-    this.config = config;
-    this.apiKey = config.apiKey || null;
-    this.workerUrl = config.workerUrl || WORKER_URL;
-    
-    const supabaseConfig = {
-      auth: {
-        persistSession: true,
-        autoRefreshToken: true,
-        detectSessionInUrl: false
-      }
-    };
-    if (config.storage) {
-      supabaseConfig.auth.storage = config.storage;
-    }
-    
-    this.supabase = createClient(config.supabaseUrl || SUPABASE_URL, config.supabaseKey || SUPABASE_ANON_KEY, supabaseConfig);
-    this._listeners = {};
-  }
-
-  // --- AUTO X-RAY WRAPPER ---
-  async _execute(fn, actionName) {
-    try {
-      return await fn();
-    } catch (e) {
-      console.warn(`[ByteX SDK] Error in ${actionName}. Running Auto X-RAY...`);
-      const diagnostic = await this.xray();
-      const advice = diagnostic.advice.length > 0 ? `\n[X-RAY Advice]: ${diagnostic.advice.join(' ')}` : '';
-      throw new Error(`${actionName} failed: ${e.message}${advice}`);
-    }
-  }
-
-  // --- CORE METHODS (ENHANCED WITH AUTO X-RAY) ---
-  async login(email, password) {
-    return this._execute(async () => {
-      const { data, error } = await this.supabase.auth.signInWithPassword({ email, password });
-      if (error) throw error;
-      return data.user;
-    }, 'Login');
-  }
-
-  async upload(name, data) {
-    return this._execute(async () => {
-      this._requireKey();
-      const fd = new FormData();
-      fd.append('file', data instanceof Blob ? data : new Blob([data]), name);
-      const res = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}`, { method: 'POST', body: fd });
-      if (!res.ok) throw new Error(await res.text() || res.statusText);
-      return await res.json();
-    }, 'Upload');
-  }
-
-  async downloadData(name) {
-    return this._execute(async () => {
-      this._requireKey();
-      const streamName = name.endsWith('.btx') ? name : `${name}.stream.btx`;
-      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 || ''}` } });
-      if (!res.ok) throw new Error(`Status ${res.status}`);
-      const text = await res.text();
-      try { return JSON.parse(text); } catch (e) { return text.split('\n').filter(Boolean).map(line => JSON.parse(line)); }
-    }, 'Download');
-  }
-
-  async delete(name) {
-    return this._execute(async () => {
-      this._requireKey();
-      const streamName = name.endsWith('.btx') ? name : `${name}.stream.btx`;
-      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(`Status ${res.status}`);
-      return true;
-    }, 'Delete');
-  }
-
-  /**
-   * ByteX X-RAY v2.5 (Self-Healing Diagnostic)
-   */
-  async xray() {
-    const report = { timestamp: new Date().toISOString(), sdk_version: '5.2.0', checks: {}, advice: [] };
-    const { data: { session } } = await this.supabase.auth.getSession();
-    
-    // 1. Connectivity Check
-    const start = Date.now();
-    try {
-      const res = await fetch(`${this.workerUrl}?action=list&key=${this.apiKey}`);
-      report.checks.connectivity = res.ok ? 'OK' : 'ERROR';
-      report.latency = Date.now() - start;
-    } catch (e) {
-      report.checks.connectivity = 'OFFLINE';
-      report.advice.push('ByteX Cloud is unreachable. Check your internet.');
-    }
-
-    // 2. API Key Check
-    if (!this.apiKey) {
-      report.checks.api_key = 'MISSING';
-      report.advice.push('No API Key detected. Please provide an apiKey in the constructor.');
-    } else { report.checks.api_key = 'OK'; }
-
-    // 3. Auth Check
-    report.checks.auth = session ? 'AUTHENTICATED' : 'GUEST';
-    if (!session) report.advice.push('User is not logged in. Some operations may fail.');
-
-    // 4. Platform Audit (Mobile/Web)
-    if (!this.config.storage && typeof navigator !== 'undefined') {
-      report.advice.push('Storage engine (AsyncStorage) is missing. Sessions will not persist.');
-    }
-
-    return report;
-  }
-
-  _requireKey() { if (!this.apiKey) throw new Error('API Key required!'); }
-
-  /**
-   * Copy a file within the same project under a new name.
-   */
-  async copy(sourceName, destName) {
-    return this._execute(async () => {
-      this._requireKey();
-      const src = sourceName.endsWith('.btx') ? sourceName : `${sourceName}.stream.btx`;
-      const { data: { session } } = await this.supabase.auth.getSession();
-      const res = await fetch(`${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(src)}&_cb=${Date.now()}`, {
-        headers: { 'Authorization': `Bearer ${session?.access_token || ''}` }
-      });
-      if (!res.ok) throw new Error(`File not found: ${sourceName}`);
-      const data = await res.arrayBuffer();
-      const fd = new FormData();
-      fd.append('file', new Blob([data]), destName);
-      const upRes = await fetch(`${this.workerUrl}?action=upload&key=${this.apiKey}`, { method: 'POST', body: fd });
-      if (!upRes.ok) throw new Error(await upRes.text());
-      return { source: sourceName, dest: destName };
-    }, 'Copy');
-  }
-
-  /**
-   * Move a file to a different project (API key).
-   * @param {string} name - File name to move
-   * @param {string} destApiKey - Destination project's API key
-   */
-  async move(name, destApiKey) {
-    return this._execute(async () => {
-      this._requireKey();
-      const src = name.endsWith('.btx') ? name : `${name}.stream.btx`;
-      const { data: { session } } = await this.supabase.auth.getSession();
-      // Download from source
-      const res = await fetch(`${this.workerUrl}?action=view&key=${this.apiKey}&file=${encodeURIComponent(src)}&_cb=${Date.now()}`, {
-        headers: { 'Authorization': `Bearer ${session?.access_token || ''}` }
-      });
-      if (!res.ok) throw new Error(`File not found: ${name}`);
-      const data = await res.arrayBuffer();
-      // Upload to destination
-      const fd = new FormData();
-      fd.append('file', new Blob([data]), name);
-      await fetch(`${this.workerUrl}?action=upload&key=${destApiKey}`, { method: 'POST', body: fd });
-      // Delete from source
-      await fetch(`${this.workerUrl}?action=delete&key=${this.apiKey}&file=${encodeURIComponent(src)}`, {
-        method: 'DELETE', headers: { 'Authorization': `Bearer ${session?.access_token || ''}` }
-      });
-      return { moved: name, to: destApiKey };
-    }, 'Move');
-  }
-
-  /**
-   * Tag a file with one or more labels.
-   * @param {string} fileName - The file to tag
-   * @param {string[]} tags - Array of tag strings
-   */
-  async tag(fileName, tags) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('tags', fileName) || [];
-      const merged = [...new Set([...existing, ...tags])];
-      await this._setMeta('tags', fileName, merged);
-      return { fileName, tags: merged };
-    }, 'Tag');
-  }
-
-  async getTags(fileName) {
-    return this._execute(async () => {
-      this._requireKey();
-      return await this._getMeta('tags', fileName) || [];
-    }, 'GetTags');
-  }
-
-  async removeTag(fileName, tag) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('tags', fileName) || [];
-      const updated = existing.filter(t => t !== tag);
-      await this._setMeta('tags', fileName, updated);
-      return { fileName, tags: updated };
-    }, 'RemoveTag');
-  }
-
-  /**
-   * Pin a file to protect it from bulk operations.
-   */
-  async pin(fileName) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('pins', '__global') || [];
-      if (!existing.includes(fileName)) {
-        await this._setMeta('pins', '__global', [...existing, fileName]);
-      }
-      return { pinned: fileName };
-    }, 'Pin');
-  }
-
-  async unpin(fileName) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('pins', '__global') || [];
-      await this._setMeta('pins', '__global', existing.filter(f => f !== fileName));
-      return { unpinned: fileName };
-    }, 'Unpin');
-  }
-
-  async getPins() {
-    return this._execute(async () => {
-      this._requireKey();
-      return await this._getMeta('pins', '__global') || [];
-    }, 'GetPins');
-  }
-
-  /**
-   * Save a versioned snapshot of a file.
-   */
-  async saveVersion(name) {
-    return this._execute(async () => {
-      this._requireKey();
-      const ts = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
-      return await this.copy(name, `__version__${ts}__${name}`);
-    }, 'SaveVersion');
-  }
-
-  /**
-   * List all saved versions of a file.
-   */
-  async listVersions(name) {
-    return this._execute(async () => {
-      this._requireKey();
-      const { data: { session } } = await this.supabase.auth.getSession();
-      const res = await fetch(`${this.workerUrl}?action=list&key=${this.apiKey}`, {
-        headers: { 'Authorization': `Bearer ${session?.access_token || ''}` }
-      });
-      const text = await res.text();
-      const files = text.trim().split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-      return files.filter(f => (f.file_name || '').startsWith('__version__') && (f.file_name || '').endsWith(name));
-    }, 'ListVersions');
-  }
-
-  /**
-   * Register a webhook URL to receive event notifications.
-   * Note: webhooks are stored locally/in Supabase. Your server must listen at the endpoint.
-   */
-  async addWebhook(url, events = ['upload', 'delete']) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('webhooks', '__global') || [];
-      const updated = [...existing.filter(w => w.url !== url), { url, events, createdAt: new Date().toISOString() }];
-      await this._setMeta('webhooks', '__global', updated);
-      return { url, events };
-    }, 'AddWebhook');
-  }
-
-  async getWebhooks() {
-    return this._execute(async () => {
-      this._requireKey();
-      return await this._getMeta('webhooks', '__global') || [];
-    }, 'GetWebhooks');
-  }
-
-  async removeWebhook(url) {
-    return this._execute(async () => {
-      this._requireKey();
-      const existing = await this._getMeta('webhooks', '__global') || [];
-      await this._setMeta('webhooks', '__global', existing.filter(w => w.url !== url));
-      return { removed: url };
-    }, 'RemoveWebhook');
-  }
-
-  // Internal metadata helper using Supabase
-  async _getMeta(type, key) {
-    try {
-      const { data } = await this.supabase.from('bytex_metadata').select('value').eq('api_key', this.apiKey).eq('meta_type', type).eq('meta_key', key).single();
-      return data?.value || null;
-    } catch { return null; }
-  }
-
-  async _setMeta(type, key, value) {
-    await this.supabase.from('bytex_metadata').upsert({ api_key: this.apiKey, meta_type: type, meta_key: key, value }, { onConflict: 'api_key,meta_type,meta_key' });
-  }
-}
-
-/**
- * ByteX AI (BYOM) v1.1
- * Bring Your Own Model — connect your own AI API keys
- *
- * Usage:
- *   const ai = new BytexAI({ 
- *     openai: 'sk-...', 
- *     custom: { key: '...', endpoint: 'https://api.groq.com/openai/v1' } 
- *   });
- */
-export class BytexAI {
-  constructor(keys = {}) {
-    this.keys = keys;
-  }
-
-  /**
-   * Universal chat method.
-   * @param {'openai'|'claude'|'gemini'|'custom'} provider - The AI provider
-   * @param {string} model - The model name
-   * @param {Array<{role: string, content: string}>} messages - Chat messages
-   * @param {object} options - Optional params
-   * @returns {Promise<string>} - The AI reply text
-   */
-  async chat(provider, model, messages, options = {}) {
-    switch (provider) {
-      case 'openai':   return this._openai(model, messages, options);
-      case 'claude':   return this._claude(model, messages, options);
-      case 'gemini':   return this._gemini(model, messages, options);
-      case 'custom':   return this._custom(model, messages, options);
-      default: throw new Error(`[BytexAI] Unknown provider: "${provider}". Use 'openai', 'claude', 'gemini', or 'custom'.`);
-    }
-  }
-
-  async _openai(model, messages, options) {
-    return this._openaiCompatible('https://api.openai.com/v1', this.keys.openai, model || 'gpt-4o-mini', messages, options);
-  }
-
-  async _custom(model, messages, options) {
-    const config = this.keys.custom || {};
-    if (!config.key || !config.endpoint) {
-      throw new Error('[BytexAI] Custom provider requires both "key" and "endpoint" (OpenAI-compatible).');
-    }
-    return this._openaiCompatible(config.endpoint, config.key, model, messages, options);
-  }
-
-  async _openaiCompatible(baseURL, key, model, messages, options) {
-    if (!key) throw new Error(`[BytexAI] API key for ${baseURL} is missing.`);
-    const url = baseURL.endsWith('/') ? `${baseURL}chat/completions` : `${baseURL}/chat/completions`;
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${key}` },
-      body: JSON.stringify({
-        model: model,
-        messages,
-        temperature: options.temperature ?? 0.7,
-        max_tokens: options.maxTokens ?? 1024,
-      })
-    });
-    if (!res.ok) throw new Error(`[BytexAI] API error (${baseURL}): ${await res.text()}`);
-    const data = await res.json();
-    return data.choices[0].message.content;
-  }
-
-  async _claude(model, messages, options) {
-    if (!this.keys.claude) throw new Error('[BytexAI] Claude API key is missing. Pass it via: new BytexAI({ claude: "sk-ant-..." })');
-    const system = messages.find(m => m.role === 'system')?.content;
-    const chatMessages = messages.filter(m => m.role !== 'system');
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.keys.claude,
-        'anthropic-version': '2023-06-01'
-      },
-      body: JSON.stringify({
-        model: model || 'claude-3-5-haiku-20241022',
-        max_tokens: options.maxTokens ?? 1024,
-        ...(system && { system }),
-        messages: chatMessages
-      })
-    });
-    if (!res.ok) throw new Error(`[BytexAI] Claude error: ${await res.text()}`);
-    const data = await res.json();
-    return data.content[0].text;
-  }
-
-  async _gemini(model, messages, options) {
-    if (!this.keys.gemini) throw new Error('[BytexAI] Gemini API key is missing. Pass it via: new BytexAI({ gemini: "AIza..." })');
-    const contents = messages
-      .filter(m => m.role !== 'system')
-      .map(m => ({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text: m.content }] }));
-    const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${model || 'gemini-1.5-flash'}:generateContent?key=${this.keys.gemini}`;
-    const res = await fetch(endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ contents, generationConfig: { temperature: options.temperature ?? 0.7, maxOutputTokens: options.maxTokens ?? 1024 } })
-    });
-    if (!res.ok) throw new Error(`[BytexAI] Gemini error: ${await res.text()}`);
-    const data = await res.json();
-    return data.candidates[0].content.parts[0].text;
-  }
-}
-
-// ════════════════════════════════════════════════════════════════
-// ByteX REALTIME — Database Realtime (BYOC Model)
-// Strategy: ALWAYS uses user's own Supabase (BYOC)
-//           Falls back to HTTP polling if no Supabase configured
-// Free tier: 200 concurrent connections per USER's Supabase project
-// ════════════════════════════════════════════════════════════════
-/**
- * BytexRealtime — Subscribe to database changes and broadcast events.
- *
- * ⚠️  IMPORTANT: Always use BYOC (user's own Supabase), NOT ByteX's central Supabase.
- *     ByteX's Supabase has a limit of 200 concurrent connections total.
- *     With BYOC, EACH USER gets their own 200 free concurrent connections.
- *
- * Usage (BYOC — Recommended):
- *   const rt = new BytexRealtime({
- *     supabaseUrl: 'https://your-project.supabase.co',
- *     supabaseKey: 'your-anon-key'
- *   });
- *
- * Usage (Polling fallback — no Supabase needed):
- *   const rt = new BytexRealtime({ pollUrl: 'https://api.bytex.work/', pollInterval: 5000 });
- */
-export class BytexRealtime {
-  constructor(config = {}) {
-    this._channels = new Map();
-    this._pollers = new Map();
-    this._mode = 'idle';
-
-    // Mode 1: BYOC Supabase client passed directly (legacy support)
-    if (config && typeof config.from === 'function') {
-      console.warn('[BytexRealtime] ⚠️  Passing ByteX\'s own Supabase client is not recommended for production. Use BYOC credentials to avoid shared connection limits.');
-      this.client = config;
-      this._mode = 'supabase';
-      return;
-    }
-
-    // Mode 2: BYOC — user provides their own Supabase credentials
-    if (config.supabaseUrl && config.supabaseKey) {
-      this.client = createClient(config.supabaseUrl, config.supabaseKey, {
-        realtime: { params: { eventsPerSecond: 10 } }
-      });
-      this._mode = 'supabase';
-      return;
-    }
-
-    // Mode 3: Polling fallback — no Supabase required
-    if (config.pollUrl) {
-      this._pollUrl = config.pollUrl;
-      this._pollInterval = config.pollInterval || 5000;
-      this._mode = 'polling';
-      return;
-    }
-
-    throw new Error(
-      '[BytexRealtime] Configuration required. Options:\n' +
-      '  1. BYOC (recommended): { supabaseUrl, supabaseKey } — user\'s own Supabase\n' +
-      '  2. Polling fallback:   { pollUrl, pollInterval? } — works without Supabase'
-    );
-  }
-
-  /**
-   * Subscribe to realtime database changes on a table (Supabase mode only).
-   * @param {string} table - Table name (e.g. 'messages', 'orders')
-   * @param {function} callback - Receives { event, new, old }
-   * @param {{ event?: 'INSERT'|'UPDATE'|'DELETE'|'*', filter?: string }} options
-   */
-  on(table, callback, options = {}) {
-    if (this._mode === 'polling') {
-      return this._pollTable(table, callback, options);
-    }
-
-    if (this._mode !== 'supabase') throw new Error('[BytexRealtime] No Supabase client. Provide supabaseUrl + supabaseKey.');
-
-    const event = options.event || '*';
-    const channelName = `bytex-rt-${table}-${Date.now()}`;
-    const channel = this.client
-      .channel(channelName)
-      .on('postgres_changes', {
-        event,
-        schema: options.schema || 'public',
-        table,
-        ...(options.filter && { filter: options.filter })
-      }, (payload) => callback(payload))
-      .subscribe((status) => {
-        if (status === 'CHANNEL_ERROR') {
-          console.error(`[BytexRealtime] Channel error on table "${table}". Check your Supabase config.`);
-        }
-      });
-
-    this._channels.set(channelName, channel);
-    return channelName;
-  }
-
-  /**
-   * Subscribe to a broadcast channel — acts like a room/WebSocket.
-   * @param {string} roomName - Unique room identifier
-   * @param {function} callback - Receives { event, payload }
-   * @returns {{ send, leave }} - Methods to send messages or leave the room
-   */
-  join(roomName, callback) {
-    if (this._mode !== 'supabase') {
-      throw new Error('[BytexRealtime] Broadcast channels require Supabase. Provide supabaseUrl + supabaseKey.');
-    }
-
-    const channel = this.client.channel(`bytex-room-${roomName}`, {
-      config: { broadcast: { self: false } }
-    });
-
-    channel
-      .on('broadcast', { event: '*' }, (msg) => callback(msg))
-      .subscribe();
-
-    this._channels.set(`bytex-room-${roomName}`, channel);
-
-    return {
-      /** Send a message to all members of this room. */
-      send: (event, payload) => channel.send({ type: 'broadcast', event, payload }),
-      /** Leave the room and clean up. */
-      leave: () => this.off(`bytex-room-${roomName}`)
-    };
-  }
-
-  /**
-   * Polling fallback — polls a URL and calls callback when response changes.
-   * Used when no Supabase is configured.
-   * @private
-   */
-  _pollTable(table, callback, options) {
-    let lastHash = null;
-    const pollerId = `poll-${table}-${Date.now()}`;
-
-    const poll = async () => {
-      try {
-        const url = `${this._pollUrl}?action=list&table=${table}`;
-        const res = await fetch(url);
-        const text = await res.text();
-        const hash = btoa(text.substring(0, 200));
-        if (lastHash !== null && hash !== lastHash) {
-          callback({ event: '*', source: 'poll', data: text });
-        }
-        lastHash = hash;
-      } catch (e) {
-        console.warn(`[BytexRealtime] Poll error: ${e.message}`);
-      }
-    };
-
-    poll();
-    const timer = setInterval(poll, this._pollInterval);
-    this._pollers.set(pollerId, timer);
-    return pollerId;
-  }
-
-  /**
-   * Check current realtime mode.
-   * @returns {'supabase'|'polling'|'idle'}
-   */
-  get mode() { return this._mode; }
-
-  /**
-   * Get current active connection count (Supabase mode only).
-   */
-  get connectionCount() { return this._channels.size; }
-
-  /** Unsubscribe from a specific channel or poller. */
-  off(channelId) {
-    const ch = this._channels.get(channelId);
-    if (ch) { this.client?.removeChannel(ch); this._channels.delete(channelId); return; }
-
-    const timer = this._pollers.get(channelId);
-    if (timer) { clearInterval(timer); this._pollers.delete(channelId); }
-  }
-
-  /** Disconnect all subscriptions and clean up. */
-  destroy() {
-    this._channels.forEach((ch) => this.client?.removeChannel(ch));
-    this._channels.clear();
-    this._pollers.forEach((t) => clearInterval(t));
-    this._pollers.clear();
-  }
-}
-
-
-// ════════════════════════════════════════════════════════════════
-// ByteX CRON — Scheduled Jobs via Cloudflare Workers Cron Triggers
-// Strategy: BYOC — user provides their Cloudflare API token
-// Free tier: 3 Cron Triggers per Cloudflare account (FREE)
-// ════════════════════════════════════════════════════════════════
-/**
- * BytexCron — Create and manage Cloudflare Workers Cron Triggers.
- *
- * Requires BYOC (user's Cloudflare account):
- *   const cron = new BytexCron({ cfToken: '...', cfAccountId: '...', workerName: 'my-worker' });
- */
-export class BytexCron {
-  constructor({ cfToken, cfAccountId, workerName } = {}) {
-    if (!cfToken || !cfAccountId || !workerName)
-      throw new Error('[BytexCron] Required: { cfToken, cfAccountId, workerName } — Use BYOC config from bytex dashboard.');
-    this.token = cfToken;
-    this.accountId = cfAccountId;
-    this.workerName = workerName;
-    this.base = `https://api.cloudflare.com/client/v4/accounts/${cfAccountId}`;
-  }
-
-  /** List all existing cron triggers for the worker. */
-  async list() {
-    const res = await fetch(`${this.base}/workers/scripts/${this.workerName}/schedules`, {
-      headers: { 'Authorization': `Bearer ${this.token}` }
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexCron] ${JSON.stringify(data.errors)}`);
-    return data.result?.schedules || [];
-  }
-
-  /**
-   * Add a new cron trigger (max 3 in free tier).
-   * @param {string} cron - Cron expression (e.g. '0 0 * * *' = daily at midnight)
-   */
-  async add(cron) {
-    const existing = await this.list();
-    const schedules = [...existing.map(s => ({ cron: s.cron })), { cron }];
-    const res = await fetch(`${this.base}/workers/scripts/${this.workerName}/schedules`, {
-      method: 'PUT',
-      headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify(schedules)
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexCron] ${JSON.stringify(data.errors)}`);
-    return data.result;
-  }
-
-  /**
-   * Remove a cron trigger.
-   * @param {string} cron - The exact cron string to remove
-   */
-  async remove(cron) {
-    const existing = await this.list();
-    const schedules = existing.filter(s => s.cron !== cron).map(s => ({ cron: s.cron }));
-    const res = await fetch(`${this.base}/workers/scripts/${this.workerName}/schedules`, {
-      method: 'PUT',
-      headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify(schedules)
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexCron] ${JSON.stringify(data.errors)}`);
-    return data.result;
-  }
-}
-
-// ════════════════════════════════════════════════════════════════
-// ByteX QUEUE — Message Queue via Cloudflare Queues
-// Strategy: BYOC — user provides their Cloudflare API token
-// Free tier: 1,000,000 messages/month per account (FREE)
-// ════════════════════════════════════════════════════════════════
-/**
- * BytexQueue — Create and publish to Cloudflare Queues.
- *
- * Requires BYOC (user's Cloudflare account):
- *   const queue = new BytexQueue({ cfToken: '...', cfAccountId: '...' });
- */
-export class BytexQueue {
-  constructor({ cfToken, cfAccountId } = {}) {
-    if (!cfToken || !cfAccountId)
-      throw new Error('[BytexQueue] Required: { cfToken, cfAccountId } — Use BYOC config from bytex dashboard.');
-    this.token = cfToken;
-    this.accountId = cfAccountId;
-    this.base = `https://api.cloudflare.com/client/v4/accounts/${cfAccountId}/queues`;
-  }
-
-  /** List all existing queues. */
-  async list() {
-    const res = await fetch(this.base, { headers: { 'Authorization': `Bearer ${this.token}` } });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexQueue] ${JSON.stringify(data.errors)}`);
-    return data.result || [];
-  }
-
-  /**
-   * Create a new queue.
-   * @param {string} name - Queue name (lowercase, hyphens only)
-   */
-  async create(name) {
-    const res = await fetch(this.base, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ queue_name: name })
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexQueue] ${JSON.stringify(data.errors)}`);
-    return data.result;
-  }
-
-  /**
-   * Delete a queue.
-   * @param {string} name - Queue name
-   */
-  async delete(name) {
-    const res = await fetch(`${this.base}/${name}`, {
-      method: 'DELETE',
-      headers: { 'Authorization': `Bearer ${this.token}` }
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexQueue] ${JSON.stringify(data.errors)}`);
-    return true;
-  }
-
-  /**
-   * Publish a message to a queue.
-   * @param {string} queueName - Target queue
-   * @param {object|string} body - Message content
-   * @param {object} options - { delaySeconds? }
-   */
-  async publish(queueName, body, options = {}) {
-    const message = { body: typeof body === 'string' ? body : JSON.stringify(body) };
-    if (options.delaySeconds) message.delay_seconds = options.delaySeconds;
-    const res = await fetch(`${this.base}/${queueName}/messages`, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ messages: [message] })
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexQueue] ${JSON.stringify(data.errors)}`);
-    return data.result;
-  }
-
-  /**
-   * Publish multiple messages in a single batch (max 100).
-   * @param {string} queueName - Target queue
-   * @param {Array<object|string>} items - Array of message bodies
-   */
-  async publishBatch(queueName, items) {
-    const messages = items.map(body => ({ body: typeof body === 'string' ? body : JSON.stringify(body) }));
-    const res = await fetch(`${this.base}/${queueName}/messages`, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ messages })
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexQueue] ${JSON.stringify(data.errors)}`);
-    return data.result;
-  }
-}
-
-// ════════════════════════════════════════════════════════════════
-// ByteX PROXY — Reverse Proxy via Cloudflare Workers
-// Strategy: Uses ByteX's Cloudflare (no BYOC needed for basic use)
-// Free tier: 100,000 requests/day (FREE)
-// ════════════════════════════════════════════════════════════════
-/**
- * BytexProxy — Deploy and manage Cloudflare Worker reverse proxies.
- *
- * Usage:
- *   // Use ByteX's proxy endpoint (no config needed):
- *   const url = BytexProxy.buildUrl('https://api.target.com/endpoint', { headers: {...} });
- *
- *   // Or deploy your own proxy Worker (BYOC):
- *   const proxy = new BytexProxy({ cfToken: '...', cfAccountId: '...' });
- *   await proxy.deploy('my-proxy', 'https://api.target.com');
- */
-export class BytexProxy {
-  constructor({ cfToken, cfAccountId } = {}) {
-    this.token = cfToken;
-    this.accountId = cfAccountId;
-  }
-
-  /**
-   * Build a proxied URL via ByteX's own proxy layer.
-   * Useful for CORS bypass and header injection.
-   * @param {string} targetUrl - The destination URL to proxy
-   * @param {{ headers?: object }} options
-   */
-  static buildUrl(targetUrl, options = {}) {
-    const encoded = encodeURIComponent(targetUrl);
-    const base = 'https://api.bytex.work/?action=proxy&target=';
-    return `${base}${encoded}`;
-  }
-
-  /**
-   * Deploy a Cloudflare Worker that proxies to a target origin (BYOC).
-   * @param {string} workerName - Unique name for this proxy worker
-   * @param {string} targetOrigin - Base URL of the backend (e.g. 'https://my-api.com')
-   * @param {{ injectHeaders?: object, stripHeaders?: string[] }} options
-   */
-  async deploy(workerName, targetOrigin, options = {}) {
-    if (!this.token || !this.accountId)
-      throw new Error('[BytexProxy] BYOC required for deploy. Pass { cfToken, cfAccountId }.');
-
-    const injectHeaders = options.injectHeaders
-      ? Object.entries(options.injectHeaders).map(([k, v]) => `req.headers.set('${k}', '${v}');`).join('\n      ')
-      : '';
-    const stripHeaders = (options.stripHeaders || [])
-      .map(h => `req.headers.delete('${h}');`).join('\n      ');
-
-    const workerScript = `
-export default {
-  async fetch(request) {
-    const url = new URL(request.url);
-    const target = new URL('${targetOrigin}' + url.pathname + url.search);
-    const req = new Request(target, request);
-    ${injectHeaders}
-    ${stripHeaders}
-    const response = await fetch(req);
-    const res = new Response(response.body, response);
-    res.headers.set('Access-Control-Allow-Origin', '*');
-    return res;
-  }
-}`;
-
-    const fd = new FormData();
-    fd.append('metadata', JSON.stringify({ main_module: 'worker.js', compatibility_date: '2024-01-01' }));
-    fd.append('worker.js', new Blob([workerScript], { type: 'application/javascript+module' }), 'worker.js');
-
-    const res = await fetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/workers/scripts/${workerName}`, {
-      method: 'PUT',
-      headers: { 'Authorization': `Bearer ${this.token}` },
-      body: fd
-    });
-    const data = await res.json();
-    if (!data.success) throw new Error(`[BytexProxy] ${JSON.stringify(data.errors)}`);
-    return { workerName, url: `https://${workerName}.workers.dev`, target: targetOrigin };
-  }
-}
-
-// ════════════════════════════════════════════════════════════════
-// ByteX MQTT — IoT Messaging via user's MQTT Broker
-// Strategy: BYOC — user provides their broker (HiveMQ/EMQX/any)
-// Free tier: HiveMQ Cloud free (10 devices), EMQX Serverless (1M msg/mo)
-// ════════════════════════════════════════════════════════════════
-/**
- * BytexMQTT — Lightweight MQTT client wrapper (BYOC).
- *
- * Requires the 'mqtt' package: npm install mqtt
- * Requires user's own MQTT broker (HiveMQ, EMQX, Mosquitto, etc.)
- *
- * Usage:
- *   const mq = new BytexMQTT({
- *     brokerUrl: 'mqtts://your-cluster.hivemq.cloud:8883',
- *     username: 'user', password: 'pass'
- *   });
- *   await mq.connect();
- *   mq.subscribe('bytex/files/#', (topic, msg) => console.log(topic, msg));
- *   mq.publish('bytex/files/new', { name: 'photo.jpg' });
- */
-export class BytexMQTT {
-  constructor({ brokerUrl, username, password, clientId } = {}) {
-    if (!brokerUrl)
-      throw new Error('[BytexMQTT] Required: { brokerUrl } — Get free broker at hivemq.com or emqx.com (BYOC).');
-    this.brokerUrl = brokerUrl;
-    this.options = {
-      username, password,
-      clientId: clientId || `bytex-${Math.random().toString(36).substring(2, 9)}`,
-      clean: true,
-      reconnectPeriod: 3000,
-      connectTimeout: 10000,
-    };
-    this.client = null;
-    this._handlers = new Map();
-  }
-
-  /**
-   * Connect to the MQTT broker.
-   * @returns {Promise<void>}
-   */
-  async connect() {
-    let mqtt;
-    try { mqtt = (await import('mqtt')).default; }
-    catch { throw new Error('[BytexMQTT] Install the mqtt package first: npm install mqtt'); }
-
-    return new Promise((resolve, reject) => {
-      this.client = mqtt.connect(this.brokerUrl, this.options);
-      this.client.on('connect', () => resolve());
-      this.client.on('error', (err) => reject(new Error(`[BytexMQTT] Connection failed: ${err.message}`)));
-      this.client.on('message', (topic, buf) => {
-        const msg = buf.toString();
-        let parsed; try { parsed = JSON.parse(msg); } catch { parsed = msg; }
-        this._handlers.forEach((fn, pattern) => {
-          if (this._topicMatch(pattern, topic)) fn(topic, parsed);
-        });
-      });
-    });
-  }
-
-  /**
-   * Publish a message to a topic.
-   * @param {string} topic
-   * @param {object|string} payload
-   * @param {{ qos?: 0|1|2, retain?: boolean }} options
-   */
-  publish(topic, payload, options = {}) {
-    if (!this.client) throw new Error('[BytexMQTT] Not connected. Call connect() first.');
-    const msg = typeof payload === 'string' ? payload : JSON.stringify(payload);
-    this.client.publish(topic, msg, { qos: options.qos ?? 1, retain: options.retain ?? false });
-  }
-
-  /**
-   * Subscribe to a topic or wildcard pattern.
-   * @param {string} topic - Supports MQTT wildcards: '#' (multi-level), '+' (single-level)
-   * @param {function} callback - (topic, parsedPayload) => void
-   * @param {{ qos?: 0|1|2 }} options
-   */
-  subscribe(topic, callback, options = {}) {
-    if (!this.client) throw new Error('[BytexMQTT] Not connected. Call connect() first.');
-    this.client.subscribe(topic, { qos: options.qos ?? 1 });
-    this._handlers.set(topic, callback);
-  }
-
-  /** Unsubscribe from a topic. */
-  unsubscribe(topic) {
-    if (this.client) this.client.unsubscribe(topic);
-    this._handlers.delete(topic);
-  }
-
-  /** Gracefully disconnect from the broker. */
-  disconnect() {
-    if (this.client) { this.client.end(); this.client = null; }
-  }
-
-  _topicMatch(pattern, topic) {
-    const p = pattern.replace(/\+/g, '[^/]+').replace(/#$/, '.*');
-    return new RegExp(`^${p}$`).test(topic);
-  }
-}
-

package/postinstall.js

@@ -1,26 +0,0 @@
-import chalk from 'chalk';
-
-console.log('');
-console.log(chalk.blue.bold('========================================='));
-console.log(chalk.cyan.bold('  🚀 Successfully installed ByteX SDK!'));
-console.log(chalk.blue.bold('========================================='));
-console.log('');
-console.log(chalk.white('Get started by importing the SDK into your project:'));
-console.log('');
-console.log(chalk.gray('  // 1. Initialize ByteX'));
-console.log(chalk.green("  import { BytexCloud } from 'bytex-sdk';"));
-console.log(chalk.green("  const bytex = new BytexCloud();"));
-console.log('');
-console.log(chalk.gray('  // 2. Login & Generate/Select API Key directly in code'));
-console.log(chalk.green("  await bytex.login('your@email.com', 'password');"));
-console.log(chalk.green("  const myKey = await bytex.createKey('My Web App');"));
-console.log(chalk.gray('  // (The active API Key is now set automatically!)'));
-console.log('');
-console.log(chalk.gray('  // 3. Upload a file'));
-console.log(chalk.green("  await bytex.upload('document.pdf', fileData);"));
-console.log('');
-console.log(chalk.white('Want to do this via terminal instead? Try the CLI:'));
-console.log(chalk.cyan('  npx bytex-cli init'));
-console.log('');
-console.log(chalk.gray('For full SDK documentation, visit: https://bytex.work/docs'));
-console.log('');