holosphere 1.1.20 → 2.0.0-alpha1

package/src/storage/backends/activitypub-backend.js

@@ -0,0 +1,272 @@
+/**
+ * ActivityPub Storage Backend
+ * Client adapter for connecting to an ActivityPub server
+ */
+
+import { StorageBackend } from '../backend-interface.js';
+
+export class ActivityPubBackend extends StorageBackend {
+  constructor(config) {
+    super(config);
+    this.serverUrl = config.serverUrl;
+    this.actorName = config.appName || 'holosphere';
+    this.apiKey = config.apiKey;
+    this.actorId = null;
+  }
+
+  async init() {
+    if (!this.serverUrl) {
+      throw new Error('ActivityPub backend requires serverUrl in config');
+    }
+
+    // Ensure server URL doesn't have trailing slash
+    this.serverUrl = this.serverUrl.replace(/\/$/, '');
+
+    // Try to fetch or create actor
+    try {
+      const response = await fetch(`${this.serverUrl}/actor/${this.actorName}`, {
+        headers: { 'Accept': 'application/activity+json' },
+      });
+
+      if (response.ok) {
+        const actor = await response.json();
+        this.actorId = actor.id;
+        this.publicKey = actor.publicKey?.id || actor.id;
+      } else {
+        // Try to create actor
+        await this._createActor();
+      }
+    } catch (error) {
+      // Server might not be running yet, try to create actor
+      await this._createActor();
+    }
+  }
+
+  async _createActor() {
+    try {
+      const response = await this._fetch(`${this.serverUrl}/api/actors`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: this.actorName,
+          apiKey: this.apiKey,
+        }),
+      });
+
+      if (response.ok) {
+        const result = await response.json();
+        this.actorId = result.id;
+        this.publicKey = result.publicKey || result.id;
+      } else {
+        throw new Error(`Failed to create actor: ${response.status}`);
+      }
+    } catch (error) {
+      // If server is not available, set placeholder values
+      this.actorId = `${this.serverUrl}/actor/${this.actorName}`;
+      this.publicKey = this.actorId;
+    }
+  }
+
+  buildPath(appName, holonId, lensName, key = null) {
+    // Use same path format as other backends
+    const encodedHolon = encodeURIComponent(holonId);
+    const encodedLens = encodeURIComponent(lensName);
+
+    if (key) {
+      const encodedKey = encodeURIComponent(key);
+      return `${appName}/${encodedHolon}/${encodedLens}/${encodedKey}`;
+    }
+    return `${appName}/${encodedHolon}/${encodedLens}`;
+  }
+
+  async write(path, data, options = {}) {
+    const response = await this._fetch(`${this.serverUrl}/api/data`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        path,
+        data,
+        actorName: this.actorName,
+      }),
+    });
+
+    return response.ok;
+  }
+
+  async read(path, options = {}) {
+    const response = await this._fetch(`${this.serverUrl}/api/data/${path}`);
+
+    if (!response.ok) {
+      if (response.status === 404) return null;
+      throw new Error(`Read failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data._deleted ? null : data;
+  }
+
+  async readAll(path, options = {}) {
+    const response = await this._fetch(`${this.serverUrl}/api/data/${path}`);
+
+    if (!response.ok) {
+      if (response.status === 404) return [];
+      throw new Error(`ReadAll failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return Array.isArray(data) ? data.filter(item => !item._deleted) : [data];
+  }
+
+  async update(path, updates) {
+    // Read existing, merge, write back
+    const existing = await this.read(path);
+    if (!existing) return false;
+
+    const merged = { ...existing, ...updates };
+    return this.write(path, merged);
+  }
+
+  async delete(path) {
+    const response = await this._fetch(
+      `${this.serverUrl}/api/data/${path}?actor=${this.actorName}`,
+      { method: 'DELETE' }
+    );
+
+    return response.ok;
+  }
+
+  async deleteAll(path) {
+    const items = await this.readAll(path);
+    let count = 0;
+
+    for (const item of items) {
+      if (item && item.id) {
+        await this.delete(`${path}/${item.id}`);
+        count++;
+      }
+    }
+
+    return { success: true, count };
+  }
+
+  async subscribe(path, callback, options = {}) {
+    // Use Server-Sent Events for real-time updates
+    const url = `${this.serverUrl}/subscribe?path=${encodeURIComponent(path)}`;
+
+    // Use EventSource if available (browser) or polyfill
+    let eventSource;
+
+    if (typeof EventSource !== 'undefined') {
+      eventSource = new EventSource(url);
+    } else {
+      // In Node.js, we need to use a different approach
+      // For now, return a polling-based subscription
+      return this._pollSubscribe(path, callback, options);
+    }
+
+    eventSource.addEventListener('update', (event) => {
+      try {
+        const { path: eventPath, data } = JSON.parse(event.data);
+        const key = eventPath.split('/').pop();
+        callback(data, key);
+      } catch (error) {
+        console.error('ActivityPub subscription error:', error);
+      }
+    });
+
+    eventSource.onerror = (error) => {
+      console.error('ActivityPub SSE error:', error);
+    };
+
+    return {
+      unsubscribe: () => eventSource.close(),
+    };
+  }
+
+  async _pollSubscribe(path, callback, options = {}) {
+    // Fallback polling for Node.js environments
+    const interval = options.pollInterval || 5000;
+    let lastTimestamp = Date.now();
+    let running = true;
+
+    const poll = async () => {
+      while (running) {
+        try {
+          const items = await this.readAll(path);
+          for (const item of items) {
+            if (item._meta?.timestamp > lastTimestamp) {
+              const key = item.id || item._meta?.path?.split('/').pop();
+              callback(item, key);
+              lastTimestamp = item._meta.timestamp;
+            }
+          }
+        } catch (error) {
+          console.error('Polling error:', error);
+        }
+
+        await new Promise(resolve => setTimeout(resolve, interval));
+      }
+    };
+
+    // Start polling
+    poll();
+
+    return {
+      unsubscribe: () => { running = false; },
+    };
+  }
+
+  async exportData(pathPrefix = '') {
+    const items = await this.readAll(pathPrefix || this.actorName);
+
+    return items.map(item => ({
+      path: item._meta?.path || `${pathPrefix}/${item.id}`,
+      data: item,
+      timestamp: item._meta?.timestamp || Date.now(),
+    }));
+  }
+
+  async importData(records, options = {}) {
+    const results = { success: 0, failed: 0, errors: [] };
+
+    for (const record of records) {
+      try {
+        await this.write(record.path, record.data);
+        results.success++;
+      } catch (error) {
+        results.failed++;
+        results.errors.push({ path: record.path, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  async _fetch(url, options = {}) {
+    const headers = options.headers || {};
+
+    // Add authorization if we have an API key
+    if (this.apiKey) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`;
+    }
+
+    return fetch(url, { ...options, headers });
+  }
+
+  close() {
+    // Nothing to close for HTTP client
+  }
+
+  getStatus() {
+    return {
+      type: 'activitypub',
+      serverUrl: this.serverUrl,
+      actorId: this.actorId,
+      actorName: this.actorName,
+      publicKey: this.publicKey,
+      connected: true,
+    };
+  }
+}
+
+export default ActivityPubBackend;

package/src/storage/backends/gundb-backend.js

@@ -0,0 +1,233 @@
+/**
+ * GunDB Storage Backend
+ * Wraps existing gun-wrapper.js as a StorageBackend
+ */
+
+import { StorageBackend } from '../backend-interface.js';
+import * as wrapper from '../gun-wrapper.js';
+import { gunPromise, gunPut, gunMap, gunCollect } from '../gun-async.js';
+
+export class GunDBBackend extends StorageBackend {
+  constructor(config) {
+    super(config);
+    this.gun = null;
+    this.keyPair = null;
+  }
+
+  async init() {
+    // Dynamically import Gun to avoid issues if not installed
+    let Gun;
+    try {
+      const gunModule = await import('gun');
+      Gun = gunModule.default || gunModule;
+    } catch (error) {
+      throw new Error(
+        'GunDB backend requires the "gun" package. Install it with: npm install gun'
+      );
+    }
+
+    const gunConfig = {
+      peers: this.config.peers || [],
+      radisk: this.config.radisk !== false,
+      localStorage: this.config.localStorage !== false,
+      file: this.config.dataDir,
+    };
+
+    this.gun = Gun(gunConfig);
+
+    // Generate or use provided key pair using Gun's SEA
+    try {
+      const SEA = Gun.SEA;
+      if (SEA) {
+        if (this.config.privateKey) {
+          // Try to restore from existing key
+          this.keyPair = { priv: this.config.privateKey, pub: this.config.publicKey };
+          this.publicKey = this.config.publicKey || this.config.privateKey.substring(0, 32);
+        } else {
+          // Generate new key pair
+          this.keyPair = await SEA.pair();
+          this.publicKey = this.keyPair.pub;
+        }
+      } else {
+        // SEA not available, use simple identifier
+        this.publicKey = this.config.appName || 'gundb-user';
+      }
+    } catch (error) {
+      // SEA might not be loaded
+      this.publicKey = this.config.appName || 'gundb-user';
+    }
+  }
+
+  buildPath(appName, holonId, lensName, key = null) {
+    return wrapper.buildPath(appName, holonId, lensName, key);
+  }
+
+  async write(path, data, options = {}) {
+    return wrapper.write(this.gun, path, data);
+  }
+
+  async read(path, options = {}) {
+    return wrapper.read(this.gun, path);
+  }
+
+  async readAll(path, options = {}) {
+    return wrapper.readAll(this.gun, path);
+  }
+
+  async update(path, updates) {
+    return wrapper.update(this.gun, path, updates);
+  }
+
+  async delete(path) {
+    return wrapper.deleteData(this.gun, path);
+  }
+
+  async deleteAll(path) {
+    // Gun doesn't have a native deleteAll, so we iterate and delete
+    const items = await this.readAll(path);
+    let count = 0;
+
+    for (const item of items) {
+      if (item && item.id) {
+        const itemPath = `${path}/${item.id}`;
+        await wrapper.deleteData(this.gun, itemPath);
+        count++;
+      }
+    }
+
+    return { success: true, count };
+  }
+
+  async subscribe(path, callback, options = {}) {
+    // Determine if this is a prefix subscription (no key) or single item
+    const pathParts = path.split('/');
+    const isPrefix = pathParts.length <= 3;
+
+    if (isPrefix) {
+      // Subscribe to all items under this prefix
+      const ref = this.gun.get(path);
+      const handlers = [];
+
+      ref.map().on((data, key) => {
+        if (data && !key.startsWith('_') && !data._deleted) {
+          callback(data, key);
+        }
+      });
+
+      // Store reference for cleanup
+      handlers.push(ref);
+
+      return {
+        unsubscribe: () => {
+          handlers.forEach(h => {
+            try {
+              h.off();
+            } catch (e) {
+              // Ignore cleanup errors
+            }
+          });
+        },
+      };
+    } else {
+      // Subscribe to single item
+      const unsubFn = wrapper.subscribe(this.gun, path, callback);
+      return {
+        unsubscribe: typeof unsubFn === 'function' ? unsubFn : () => {},
+      };
+    }
+  }
+
+  async exportData(pathPrefix = '') {
+    const records = [];
+
+    // Get the app-level data
+    const appName = this.config.appName || 'holosphere';
+    const basePath = pathPrefix || appName;
+
+    try {
+      const items = await gunMap(this.gun.get(basePath), 2000);
+
+      for (const [key, data] of Object.entries(items)) {
+        if (!key.startsWith('_') && data && typeof data === 'object' && !data._deleted) {
+          // Recursively collect nested data
+          await this._collectRecords(basePath, key, data, records);
+        }
+      }
+    } catch (error) {
+      console.warn('Export data error:', error);
+    }
+
+    return records;
+  }
+
+  async _collectRecords(basePath, key, data, records) {
+    const currentPath = `${basePath}/${key}`;
+
+    if (data.id) {
+      // This is a leaf data node
+      records.push({
+        path: currentPath,
+        data: this._cleanGunData(data),
+        timestamp: data._meta?.timestamp || Date.now(),
+      });
+    } else {
+      // This might be a nested structure, explore further
+      try {
+        const nested = await gunMap(this.gun.get(currentPath), 500);
+        for (const [nestedKey, nestedData] of Object.entries(nested)) {
+          if (!nestedKey.startsWith('_') && nestedData) {
+            await this._collectRecords(currentPath, nestedKey, nestedData, records);
+          }
+        }
+      } catch (e) {
+        // Ignore nested exploration errors
+      }
+    }
+  }
+
+  _cleanGunData(data) {
+    // Remove Gun's internal metadata
+    const cleaned = { ...data };
+    delete cleaned['_'];
+    return cleaned;
+  }
+
+  async importData(records, options = {}) {
+    const results = { success: 0, failed: 0, errors: [] };
+
+    for (const record of records) {
+      try {
+        await wrapper.write(this.gun, record.path, record.data);
+        results.success++;
+      } catch (error) {
+        results.failed++;
+        results.errors.push({ path: record.path, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  close() {
+    // Gun doesn't have explicit close, but we can try to clean up
+    if (this.gun) {
+      try {
+        // Attempt to close any connections
+        this.gun.off();
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  getStatus() {
+    return {
+      type: 'gundb',
+      publicKey: this.publicKey,
+      peers: this.config.peers || [],
+      connected: !!this.gun,
+    };
+  }
+}
+
+export default GunDBBackend;

package/src/storage/backends/nostr-backend.js

@@ -0,0 +1,136 @@
+/**
+ * Nostr Storage Backend
+ * Wraps existing nostr-wrapper.js and nostr-client.js as a StorageBackend
+ */
+
+import { StorageBackend } from '../backend-interface.js';
+import { createClient } from '../nostr-client.js';
+import * as wrapper from '../nostr-wrapper.js';
+
+export class NostrBackend extends StorageBackend {
+  constructor(config) {
+    super(config);
+    this.client = null;
+  }
+
+  async init() {
+    this.client = createClient({
+      relays: this.config.relays || ['wss://relay.holons.io'],
+      privateKey: this.config.privateKey,
+      enableReconnect: this.config.enableReconnect !== false,
+      enablePing: this.config.enablePing !== false,
+      appName: this.config.appName,
+      radisk: this.config.radisk !== false,
+      persistence: this.config.persistence !== false,
+      dataDir: this.config.dataDir,
+      backgroundSync: this.config.backgroundSync,
+      syncInterval: this.config.syncInterval,
+    });
+
+    // Wait for client initialization
+    await this.client._initReady;
+    this.publicKey = this.client.publicKey;
+  }
+
+  buildPath(appName, holonId, lensName, key = null) {
+    return wrapper.buildPath(appName, holonId, lensName, key);
+  }
+
+  async write(path, data, options = {}) {
+    return wrapper.write(this.client, path, data);
+  }
+
+  async read(path, options = {}) {
+    return wrapper.read(this.client, path, options);
+  }
+
+  async readAll(path, options = {}) {
+    return wrapper.readAll(this.client, path, options);
+  }
+
+  async update(path, updates) {
+    return wrapper.update(this.client, path, updates);
+  }
+
+  async delete(path) {
+    return wrapper.deleteData(this.client, path);
+  }
+
+  async deleteAll(path) {
+    return wrapper.deleteAll(this.client, path);
+  }
+
+  async subscribe(path, callback, options = {}) {
+    return wrapper.subscribe(this.client, path, callback, options);
+  }
+
+  async exportData(pathPrefix = '') {
+    // Wait for client to be ready
+    await this.client._initReady;
+
+    // Query all events for this author
+    const events = await this.client.query({
+      kinds: [30000],
+      authors: [this.publicKey],
+      limit: 10000,
+    });
+
+    return events
+      .filter(e => {
+        const dTag = e.tags.find(t => t[0] === 'd');
+        if (!dTag) return false;
+        // Filter by prefix if provided
+        if (pathPrefix && !dTag[1].startsWith(pathPrefix)) return false;
+        return true;
+      })
+      .map(e => {
+        const dTag = e.tags.find(t => t[0] === 'd');
+        let data;
+        try {
+          data = JSON.parse(e.content);
+        } catch {
+          data = { content: e.content };
+        }
+        return {
+          path: dTag[1],
+          data,
+          timestamp: e.created_at * 1000,
+          author: e.pubkey,
+        };
+      })
+      .filter(record => !record.data._deleted); // Filter out deleted items
+  }
+
+  async importData(records, options = {}) {
+    const results = { success: 0, failed: 0, errors: [] };
+
+    for (const record of records) {
+      try {
+        await wrapper.write(this.client, record.path, record.data);
+        results.success++;
+      } catch (error) {
+        results.failed++;
+        results.errors.push({ path: record.path, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  close() {
+    if (this.client) {
+      this.client.close();
+    }
+  }
+
+  getStatus() {
+    return {
+      type: 'nostr',
+      publicKey: this.publicKey,
+      relays: this.config.relays || [],
+      connected: !!this.client,
+    };
+  }
+}
+
+export default NostrBackend;

package/src/storage/filesystem-storage-browser.js

@@ -0,0 +1,41 @@
+/**
+ * Browser stub for FileSystemStorage
+ * Throws an error if used in browser environment
+ */
+
+import { PersistentStorage } from './persistent-storage.js';
+
+export class FileSystemStorage extends PersistentStorage {
+  constructor(baseDir = null) {
+    super();
+    throw new Error('FileSystemStorage is not available in browser environments. Use IndexedDBStorage or MemoryStorage instead.');
+  }
+
+  async init(namespace) {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async put(key, event) {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async get(key) {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async getAll(prefix) {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async delete(key) {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async clear() {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+
+  async close() {
+    throw new Error('FileSystemStorage is not available in browser environments');
+  }
+}