bytex-sdk 5.1.0 → 5.3.0

package/index.js

@@ -88,7 +88,7 @@ export class BytexCloud {
    * ByteX X-RAY v2.5 (Self-Healing Diagnostic)
    */
   async xray() {
-    const report = { timestamp: new Date().toISOString(), sdk_version: '2.1.0', checks: {}, advice: [] };
+    const report = { timestamp: new Date().toISOString(), sdk_version: '5.2.0', checks: {}, advice: [] };
     const { data: { session } } = await this.supabase.auth.getSession();
     
     // 1. Connectivity Check
@@ -121,15 +121,197 @@ export class BytexCloud {
   }
 
   _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.0
- * Bring Your Own Model — connect your own AI API keys (OpenAI, Claude, Gemini)
+ * ByteX AI (BYOM) v1.1
+ * Bring Your Own Model — connect your own AI API keys
  *
  * Usage:
- *   const ai = new BytexAI({ openai: 'sk-...', claude: 'sk-ant-...', gemini: 'AIza...' });
- *   const reply = await ai.chat('openai', 'gpt-4o', [{ role: 'user', content: 'Hello!' }]);
+ *   const ai = new BytexAI({ 
+ *     openai: 'sk-...', 
+ *     custom: { key: '...', endpoint: 'https://api.groq.com/openai/v1' } 
+ *   });
  */
 export class BytexAI {
   constructor(keys = {}) {
@@ -138,10 +320,10 @@ export class BytexAI {
 
   /**
    * Universal chat method.
-   * @param {'openai'|'claude'|'gemini'} provider - The AI provider
-   * @param {string} model - The model name (e.g. 'gpt-4o', 'claude-3-5-sonnet-20241022', 'gemini-1.5-pro')
+   * @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 (temperature, maxTokens, etc.)
+   * @param {object} options - Optional params
    * @returns {Promise<string>} - The AI reply text
    */
   async chat(provider, model, messages, options = {}) {
@@ -149,23 +331,37 @@ export class BytexAI {
       case 'openai':   return this._openai(model, messages, options);
       case 'claude':   return this._claude(model, messages, options);
       case 'gemini':   return this._gemini(model, messages, options);
-      default: throw new Error(`[BytexAI] Unknown provider: "${provider}". Use 'openai', 'claude', or 'gemini'.`);
+      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) {
-    if (!this.keys.openai) throw new Error('[BytexAI] OpenAI API key is missing. Pass it via: new BytexAI({ openai: "sk-..." })');
-    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    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 ${this.keys.openai}` },
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${key}` },
       body: JSON.stringify({
-        model: model || 'gpt-4o-mini',
+        model: model,
         messages,
         temperature: options.temperature ?? 0.7,
         max_tokens: options.maxTokens ?? 1024,
       })
     });
-    if (!res.ok) throw new Error(`[BytexAI] OpenAI error: ${await res.text()}`);
+    if (!res.ok) throw new Error(`[BytexAI] API error (${baseURL}): ${await res.text()}`);
     const data = await res.json();
     return data.choices[0].message.content;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bytex-sdk",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "Official ByteX Cloud SDK with AI (BYOM) support",
   "main": "index.js",
   "scripts": {