bytex-sdk 5.2.0 → 5.4.0

package/index.js

@@ -121,6 +121,186 @@ 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' });
+  }
 }
 
 /**
@@ -225,3 +405,416 @@ export class BytexAI {
     return data.candidates[0].content.parts[0].text;
   }
 }
+
+// ════════════════════════════════════════════════════════════════
+// ByteX REALTIME — Database Realtime via Supabase
+// Strategy: Uses ByteX's Supabase OR user's own (BYOC)
+// Free tier: 200 concurrent connections per Supabase project
+// ════════════════════════════════════════════════════════════════
+/**
+ * BytexRealtime — Subscribe to database changes in real-time.
+ *
+ * Usage:
+ *   const rt = new BytexRealtime(bytex.supabase);
+ *   rt.on('api_keys', (payload) => console.log(payload));
+ */
+export class BytexRealtime {
+  constructor(supabaseClient) {
+    if (!supabaseClient) throw new Error('[BytexRealtime] Pass a Supabase client. Use: new BytexRealtime(bytex.supabase)');
+    this.client = supabaseClient;
+    this._channels = new Map();
+  }
+
+  /**
+   * Subscribe to realtime changes on a table.
+   * @param {string} table - Table name (e.g. 'api_keys', 'files')
+   * @param {function} callback - Receives { event, new, old }
+   * @param {{ event?: 'INSERT'|'UPDATE'|'DELETE'|'*', filter?: string }} options
+   */
+  on(table, callback, options = {}) {
+    const event = options.event || '*';
+    const channelName = `bytex-rt-${table}-${Date.now()}`;
+    const channel = this.client
+      .channel(channelName)
+      .on('postgres_changes', {
+        event,
+        schema: 'public',
+        table,
+        ...(options.filter && { filter: options.filter })
+      }, (payload) => callback(payload))
+      .subscribe();
+    this._channels.set(channelName, channel);
+    return channelName;
+  }
+
+  /**
+   * Subscribe to a broadcast channel (WebSocket replacement).
+   * @param {string} channelName - Unique room/channel name
+   * @param {function} callback - Receives { event, payload }
+   */
+  join(channelName, callback) {
+    const channel = this.client.channel(channelName);
+    channel.on('broadcast', { event: '*' }, (msg) => callback(msg)).subscribe();
+    this._channels.set(channelName, channel);
+    return {
+      send: (event, payload) => channel.send({ type: 'broadcast', event, payload }),
+      leave: () => this.off(channelName)
+    };
+  }
+
+  /**
+   * Unsubscribe from a channel.
+   * @param {string} channelName
+   */
+  off(channelName) {
+    const ch = this._channels.get(channelName);
+    if (ch) { this.client.removeChannel(ch); this._channels.delete(channelName); }
+  }
+
+  /** Remove all active subscriptions. */
+  destroy() {
+    this._channels.forEach((ch) => this.client.removeChannel(ch));
+    this._channels.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/package.json

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