holosphere 1.1.20 → 2.0.0-alpha1

package/src/storage/indexeddb-storage.js

@@ -0,0 +1,122 @@
+/**
+ * IndexedDB storage adapter for browsers
+ * Provides persistent storage with good performance
+ */
+
+import { PersistentStorage } from './persistent-storage.js';
+
+export class IndexedDBStorage extends PersistentStorage {
+  constructor() {
+    super();
+    this.db = null;
+    this.dbName = null;
+    this.storeName = 'events';
+  }
+
+  async init(namespace) {
+    this.dbName = `holosphere_${namespace}`;
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+
+        // Create object store if it doesn't exist
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          const objectStore = db.createObjectStore(this.storeName, { keyPath: 'key' });
+          // Create index for prefix queries
+          objectStore.createIndex('key', 'key', { unique: false });
+        }
+      };
+    });
+  }
+
+  async put(key, event) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readwrite');
+      const objectStore = transaction.objectStore(this.storeName);
+
+      const request = objectStore.put({ key, event, timestamp: Date.now() });
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async get(key) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readonly');
+      const objectStore = transaction.objectStore(this.storeName);
+
+      const request = objectStore.get(key);
+
+      request.onsuccess = () => {
+        const result = request.result;
+        resolve(result ? result.event : null);
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getAll(prefix) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readonly');
+      const objectStore = transaction.objectStore(this.storeName);
+
+      const results = [];
+      const request = objectStore.openCursor();
+
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          if (cursor.value.key.startsWith(prefix)) {
+            results.push(cursor.value.event);
+          }
+          cursor.continue();
+        } else {
+          resolve(results);
+        }
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async delete(key) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readwrite');
+      const objectStore = transaction.objectStore(this.storeName);
+
+      const request = objectStore.delete(key);
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async clear() {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readwrite');
+      const objectStore = transaction.objectStore(this.storeName);
+
+      const request = objectStore.clear();
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}

package/src/storage/key-storage-simple.js

@@ -0,0 +1,76 @@
+/**
+ * Simple Key Storage for Node.js
+ * Basic filesystem-based key management
+ *
+ * NOTE: This only works in Node.js, not browsers
+ * For browsers, keys are managed in localStorage
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Get key storage directory
+ */
+function getKeyDir() {
+  const configDir = process.env.XDG_CONFIG_HOME ||
+    (process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'))
+      : path.join(os.homedir(), '.config'));
+
+  return path.join(configDir, 'holosphere', 'keys');
+}
+
+/**
+ * Get key file path for an app
+ */
+function getKeyPath(appName) {
+  const safeName = appName.replace(/[^a-zA-Z0-9-_]/g, '_');
+  return path.join(getKeyDir(), `${safeName}.key`);
+}
+
+/**
+ * Load private key
+ */
+export function loadKey(appName) {
+  const keyPath = getKeyPath(appName);
+  if (fs.existsSync(keyPath)) {
+    const key = fs.readFileSync(keyPath, 'utf8').trim();
+    if (/^[0-9a-f]{64}$/i.test(key)) {
+      return key;
+    }
+  }
+  return null;
+}
+
+/**
+ * Save private key
+ */
+export function saveKey(appName, privateKey) {
+  if (!/^[0-9a-f]{64}$/i.test(privateKey)) {
+    throw new Error('Invalid private key format');
+  }
+
+  const keyPath = getKeyPath(appName);
+  const dir = path.dirname(keyPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  fs.writeFileSync(keyPath, privateKey, { mode: 0o600 });
+  return keyPath;
+}
+
+/**
+ * Get or create key
+ */
+export function getOrCreateKey(appName, generateFn) {
+  const existing = loadKey(appName);
+  if (existing) return existing;
+
+  const newKey = generateFn();
+  saveKey(appName, newKey);
+  return newKey;
+}

package/src/storage/key-storage.js

@@ -0,0 +1,136 @@
+/**
+ * Key Storage - Universal API
+ * Automatically uses Node.js or Browser implementation
+ */
+
+/**
+ * Lazy-loaded Node.js modules
+ */
+let nodeModules = null;
+
+function getNodeModules() {
+  if (!nodeModules) {
+    try {
+      // Use globalThis to access Node.js built-ins
+      const fs = globalThis.require?.('fs') || eval('require')('fs');
+      const path = globalThis.require?.('path') || eval('require')('path');
+      const os = globalThis.require?.('os') || eval('require')('os');
+
+      const getKeyPath = (appName, keyDir) => {
+        const configDir = process.env.XDG_CONFIG_HOME ||
+          (process.platform === 'win32'
+            ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'))
+            : path.join(os.homedir(), '.config'));
+        const dir = keyDir || path.join(configDir, 'holosphere', 'keys');
+        const safeName = appName.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return path.join(dir, `${safeName}.key`);
+      };
+
+      nodeModules = { fs, path, os, getKeyPath };
+    } catch (error) {
+      console.warn('Failed to load Node.js modules:', error);
+      nodeModules = null;
+    }
+  }
+  return nodeModules;
+}
+
+/**
+ * Load private key from storage
+ * @param {string} appName - Application name
+ * @param {Object} options - Options
+ * @returns {string|null} Private key or null
+ */
+export function loadPrivateKey(appName, options = {}) {
+  // Browser environment
+  if (typeof window !== 'undefined' && window.localStorage) {
+    try {
+      const key = window.localStorage.getItem(`holosphere_key_${appName}`);
+      if (key && /^[0-9a-f]{64}$/i.test(key)) return key;
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Node.js environment
+  const node = getNodeModules();
+  if (!node) return null;
+
+  try {
+    const keyPath = node.getKeyPath(appName, options.keyDir);
+    if (node.fs.existsSync(keyPath)) {
+      const key = node.fs.readFileSync(keyPath, 'utf8').trim();
+      if (/^[0-9a-f]{64}$/i.test(key)) return key;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Save private key to storage
+ * @param {string} appName - Application name
+ * @param {string} privateKey - Private key (hex)
+ * @param {Object} options - Options
+ * @returns {boolean} Success
+ */
+export function savePrivateKey(appName, privateKey, options = {}) {
+  if (!/^[0-9a-f]{64}$/i.test(privateKey)) {
+    throw new Error('Invalid private key format');
+  }
+
+  // Browser environment
+  if (typeof window !== 'undefined' && window.localStorage) {
+    try {
+      window.localStorage.setItem(`holosphere_key_${appName}`, privateKey);
+      return true;
+    } catch (error) {
+      console.error('Failed to save key:', error);
+      return false;
+    }
+  }
+
+  // Node.js environment
+  const node = getNodeModules();
+  if (!node) return false;
+
+  try {
+    const keyPath = node.getKeyPath(appName, options.keyDir);
+    const dir = node.path.dirname(keyPath);
+
+    if (!node.fs.existsSync(dir)) {
+      node.fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+
+    node.fs.writeFileSync(keyPath, privateKey, { mode: 0o600 });
+    return true;
+  } catch (error) {
+    console.error('Failed to save key:', error);
+    return false;
+  }
+}
+
+/**
+ * Get or create private key for an app
+ * @param {string} appName - Application name
+ * @param {Function} generateFn - Function to generate new key
+ * @param {Object} options - Options
+ * @returns {string} Private key (hex)
+ */
+export function getOrCreatePrivateKey(appName, generateFn, options = {}) {
+  const existingKey = loadPrivateKey(appName, options);
+  if (existingKey) {
+    return existingKey;
+  }
+
+  const newKey = generateFn();
+  const saved = savePrivateKey(appName, newKey, options);
+
+  if (!saved) {
+    console.warn('Failed to save private key - key will not persist across restarts');
+  }
+
+  return newKey;
+}

package/src/storage/memory-storage.js

@@ -0,0 +1,59 @@
+/**
+ * Memory-only storage adapter (fallback, no actual persistence)
+ */
+
+import { PersistentStorage } from './persistent-storage.js';
+
+export class MemoryStorage extends PersistentStorage {
+  constructor() {
+    super();
+    this.data = new Map();
+    this.namespace = null;
+  }
+
+  async init(namespace) {
+    this.namespace = namespace;
+    // Check if there's existing data for this namespace
+    if (!MemoryStorage._globalStore) {
+      MemoryStorage._globalStore = new Map();
+    }
+    if (!MemoryStorage._globalStore.has(namespace)) {
+      MemoryStorage._globalStore.set(namespace, new Map());
+    }
+    this.data = MemoryStorage._globalStore.get(namespace);
+  }
+
+  async put(key, event) {
+    this.data.set(key, JSON.parse(JSON.stringify(event))); // Deep clone
+  }
+
+  async get(key) {
+    const data = this.data.get(key);
+    return data ? JSON.parse(JSON.stringify(data)) : null; // Deep clone
+  }
+
+  async getAll(prefix) {
+    const results = [];
+    for (const [key, value] of this.data.entries()) {
+      if (key.startsWith(prefix)) {
+        results.push(JSON.parse(JSON.stringify(value)));
+      }
+    }
+    return results;
+  }
+
+  async delete(key) {
+    this.data.delete(key);
+  }
+
+  async clear() {
+    this.data.clear();
+  }
+
+  async close() {
+    // Nothing to close for memory storage
+  }
+}
+
+// Global store shared across instances with same namespace
+MemoryStorage._globalStore = null;