@omega.js/client 0.1.0

package/dist/modules/sentry.js

@@ -0,0 +1,108 @@
+/**
+ * The client runtime's error reporting — a HOST of `@omega.js/monitoring`,
+ * never a second copy of its policy (#380).
+ *
+ * What lives here is what only the client can know: when to load the SDK, which
+ * release tag this page is (`brand.id@version`), where the signed-in user
+ * comes from (the auth storage keys), and the public surface every consumer
+ * calls — `omega.sentry().captureException(err)`.
+ *
+ * Everything else — the send gate, the @omega.js-bundle filter, the PII scrub,
+ * the integrations — is the package's, shared with the backend and the desktop
+ * main process so no surface can drift.
+ */
+
+import monitoring from '../vendor/monitoring/browser.js';
+import monitoringCore from '../vendor/monitoring/core.js';
+import { createLogger } from './logger.js';
+
+const logger = createLogger('sentry');
+
+class mod {
+  constructor(manager) {
+    this.manager = manager;
+    this.initialized = false;
+    this.Sentry = null;
+    this.config = null;
+  }
+
+  /**
+   * Initialize Sentry error tracking
+   * @param {Object} config - the resolved Sentry settings for this surface
+   *   (the build maps `monitoring.providers.sentry` into `config.sentry.config`)
+   * @returns {Promise} Resolves when initialization is complete
+   */
+  init(config = {}) {
+    // Dynamically imported to keep the SDK out of the initial chunk — and
+    // never reached at all when the config carries no DSN (index.js gates on
+    // `config.sentry.enabled`, which the build maps from
+    // `monitoring.providers.sentry.dsn`).
+    return import('@sentry/browser')
+      .then((sdk) => {
+        this.Sentry = sdk;
+
+        // Expose globally so page code and devtools can reach the same SDK
+        if (typeof window !== 'undefined') {
+          window.Sentry = sdk;
+        }
+
+        this.config = monitoring.buildInitOptions({
+          Sentry: sdk,
+          config,
+          release: monitoringCore.releaseTag({
+            id: this.manager.config.brand?.id,
+            // The host blob's app version when it carries one (@omega.js/extension
+            // bakes it, and it is the same key device stats read) — the build stamp
+            // is the fallback for a surface that ships no version yet.
+            version: this.manager.config.version || this.manager.config.buildTime,
+          }),
+          environment: this.manager.config.environment,
+          isDevelopment: () => this.manager.isDevelopment(),
+          getUser: () => {
+            const storage = this.manager.storage();
+            return {
+              uid: storage.get('auth.user.uid', ''),
+              email: storage.get('auth.user.email', ''),
+            };
+          },
+        });
+
+        sdk.init(this.config);
+        this.initialized = true;
+
+        return { initialized: true };
+      })
+      .catch((error) => {
+        logger.error('Failed to initialize:', error);
+        throw error;
+      });
+  }
+
+  /**
+   * Capture an exception and send to Sentry
+   * Safe to call even if Sentry is not initialized
+   * @param {Error} error - The error to capture
+   * @param {Object} captureContext - Additional context for the error
+   * @returns {string|null} Event ID if successful, null otherwise
+   */
+  captureException(error, captureContext) {
+    // Log the error
+    logger.error('Capturing exception:', error);
+
+    // Safe to call - won't throw if not initialized
+    if (!this.initialized) {
+      logger.log('Not initialized, skipping capture');
+      return null;
+    }
+
+    // Call Sentry to capture the exception
+    try {
+      return this.Sentry.captureException(error, captureContext);
+    } catch (captureError) {
+      logger.error('Failed to capture exception:', captureError);
+      return null;
+    }
+  }
+}
+
+export default mod;

package/dist/modules/service-worker.js

@@ -0,0 +1,237 @@
+import { createLogger } from './logger.js';
+import { pathPrefix } from './path-prefix.js';
+
+const logger = createLogger('service-worker');
+
+class ServiceWorker {
+  constructor(manager) {
+    this.manager = manager;
+    this._registration = null;
+    this._messageHandlers = new Map();
+  }
+
+  // Check if service workers are supported
+  isSupported() {
+    return 'serviceWorker' in navigator;
+  }
+
+  // Return promise that resolves when service worker is ready
+  async ready() {
+    if (!this.isSupported()) {
+      throw new Error('Service Workers not supported');
+    }
+
+    // If already registered and active
+    if (this._registration?.active) {
+      return this._registration;
+    }
+
+    // Wait for service worker to be ready
+    const registration = await navigator.serviceWorker.ready;
+    return registration;
+  }
+
+  // Register service worker
+  async register(options = {}) {
+    try {
+      if (!this.isSupported()) {
+        console.warn('Service Workers are not supported');
+        return null;
+      }
+
+      // Mount the script and the scope under the page's base path (#360): a
+      // worker served at /<prefix>/service-worker.js can only claim
+      // /<prefix>/. The prefix rides the script URL as a query param because
+      // the worker has no document to read the stamp from — it reads it back
+      // off self.location.search. No prefix leaves both untouched.
+      const prefix = pathPrefix();
+      const configuredPath = options.path || this.manager.config.serviceWorker?.config?.path || '/service-worker.js';
+      const swPath = prefix && configuredPath.startsWith('/') && !configuredPath.startsWith('//')
+        ? `${prefix}${configuredPath}`
+        : configuredPath;
+      const swUrl = prefix ? `${swPath}?omega-path-prefix=${encodeURIComponent(prefix)}` : swPath;
+      const scope = options.scope || `${prefix}/`;
+
+      // Build config object to pass to service worker
+      const config = {
+        brand: this.manager.config.brand?.id,
+        environment: this.manager.config.environment,
+        buildTime: this.manager.config.buildTime,
+        firebase: this.manager._resolveFirebaseConfig()
+      };
+
+      // Register service worker
+      const registration = await navigator.serviceWorker.register(swUrl, {
+        scope,
+        updateViaCache: 'none'
+      });
+
+      // Store registration
+      this._registration = registration;
+      this.manager.state.serviceWorker = registration;
+
+      // Wait for service worker to be ready and send config
+      await navigator.serviceWorker.ready;
+
+      // Send config to active service worker
+      // Removed due to issues init'ing firebase asynchronously in SW (now config is fetched directly in SW)
+      // if (registration.active) {
+      //   try {
+      //     this.postMessage({
+      //       command: 'update-config',
+      //       payload: config
+      //     });
+      //   } catch (error) {
+      //     console.warn('Could not send config to service worker:', error);
+      //   }
+      // }
+
+      // Resolve with registration
+      return registration;
+    } catch (error) {
+      console.error('Service Worker registration failed:', error);
+      throw error;
+    }
+  }
+
+  // Unregister every service worker claiming this origin. Dev-loop hygiene:
+  // a previous project's service worker on the same localhost port would
+  // otherwise keep controlling pages and serving its stale caches.
+  async unregisterAll() {
+    if (!this.isSupported()) {
+      return 0;
+    }
+
+    try {
+      const registrations = await navigator.serviceWorker.getRegistrations();
+
+      await Promise.all(registrations.map((registration) => registration.unregister()));
+
+      if (registrations.length > 0) {
+        logger.log(`Unregistered ${registrations.length} service worker(s) claiming this origin`);
+      }
+
+      this._registration = null;
+
+      return registrations.length;
+    } catch (error) {
+      logger.warn('Failed to unregister service workers:', error);
+      return 0;
+    }
+  }
+
+  // Get current registration
+  getRegistration() {
+    return this._registration;
+  }
+
+  // Post message to service worker
+  postMessage(message, options = {}) {
+    return new Promise((resolve, reject) => {
+      // Check support
+      if (!this.isSupported()) {
+        return reject(new Error('Service Workers not supported'));
+      }
+
+      // Get active service worker
+      const controller = this._registration?.active || navigator.serviceWorker.controller;
+
+      if (!controller) {
+        return reject(new Error('No active service worker'));
+      }
+
+      // Create message channel for two-way communication
+      const messageChannel = new MessageChannel();
+      const timeout = options.timeout || 5000;
+      let timeoutId;
+
+      // Set up timeout to prevent hanging
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          messageChannel.port1.close();
+          reject(new Error('Service worker message timeout'));
+        }, timeout);
+      }
+
+      // Listen for response from service worker
+      messageChannel.port1.onmessage = (event) => {
+        clearTimeout(timeoutId);
+
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+        } else {
+          resolve(event.data);
+        }
+      };
+
+      // Send message with port for reply
+      controller.postMessage(message, [messageChannel.port2]);
+    });
+  }
+
+  // Listen for messages from service worker
+  onMessage(type, handler) {
+    if (!this.isSupported()) {
+      return () => {};
+    }
+
+    // Store handler
+    if (!this._messageHandlers.has(type)) {
+      this._messageHandlers.set(type, new Set());
+    }
+    this._messageHandlers.get(type).add(handler);
+
+    // Set up global message listener if not already done
+    if (this._messageHandlers.size === 1) {
+      navigator.serviceWorker.addEventListener('message', this._handleMessage.bind(this));
+    }
+
+    // Return unsubscribe function
+    return () => {
+      const handlers = this._messageHandlers.get(type);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this._messageHandlers.delete(type);
+        }
+      }
+    };
+  }
+
+  // Get service worker state
+  getState() {
+    if (!this._registration) {
+      return 'none';
+    }
+
+    if (this._registration.installing) {
+      return 'installing';
+    } else if (this._registration.waiting) {
+      return 'waiting';
+    } else if (this._registration.active) {
+      return 'active';
+    }
+
+    return 'unknown';
+  }
+
+  // Private: Handle incoming messages
+  _handleMessage(event) {
+    const { type, ...data } = event.data || {};
+
+    if (!type) return;
+
+    const handlers = this._messageHandlers.get(type);
+    if (handlers) {
+      handlers.forEach(handler => {
+        try {
+          handler(data, event);
+        } catch (error) {
+          console.error('Message handler error:', error);
+        }
+      });
+    }
+  }
+}
+
+export default ServiceWorker;

package/dist/modules/storage.js

@@ -0,0 +1,133 @@
+import lodash from 'lodash';
+const { get: _get, set: _set } = lodash;
+
+class Storage {
+  constructor() {
+    this.storageKey = '_manager';
+    this.pseudoStorage = {};
+  }
+
+  get(path, defaultValue) {
+    let usableStorage;
+
+    // Try to parse the localStorage object
+    try {
+      usableStorage = JSON.parse(window.localStorage.getItem(this.storageKey) || '{}');
+    } catch (e) {
+      usableStorage = this.pseudoStorage;
+    }
+
+    // If there's no path, return the entire storage object
+    if (!path) {
+      return usableStorage || defaultValue;
+    }
+
+    // Return the value at the path
+    return _get(usableStorage, path, defaultValue);
+  }
+
+  set(path, value) {
+    let usableStorage;
+
+    // Try to get the current storage
+    try {
+      usableStorage = this.get();
+    } catch (e) {
+      usableStorage = this.pseudoStorage;
+    }
+
+    // If there's no path, replace the entire storage object
+    if (!path) {
+      usableStorage = value || {};
+    } else {
+      // Set the value at the path
+      _set(usableStorage, path, value);
+    }
+
+    // Try to set the localStorage object
+    try {
+      window.localStorage.setItem(this.storageKey, JSON.stringify(usableStorage));
+    } catch (e) {
+      this.pseudoStorage = usableStorage;
+    }
+
+    return usableStorage;
+  }
+
+  remove(path) {
+    if (!path) {
+      this.clear();
+    } else {
+      this.set(path, undefined);
+    }
+  }
+
+  clear() {
+    try {
+      window.localStorage.setItem(this.storageKey, '{}');
+    } catch (e) {
+      this.pseudoStorage = {};
+    }
+  }
+
+  // Session storage methods
+  session = {
+    get: (path, defaultValue) => {
+      let usableStorage;
+
+      try {
+        usableStorage = JSON.parse(window.sessionStorage.getItem(this.storageKey) || '{}');
+      } catch (e) {
+        return defaultValue;
+      }
+
+      if (!path) {
+        return usableStorage || defaultValue;
+      }
+
+      return _get(usableStorage, path, defaultValue);
+    },
+
+    set: (path, value) => {
+      let usableStorage;
+
+      try {
+        usableStorage = this.session.get();
+      } catch (e) {
+        usableStorage = {};
+      }
+
+      if (!path) {
+        usableStorage = value || {};
+      } else {
+        _set(usableStorage, path, value);
+      }
+
+      try {
+        window.sessionStorage.setItem(this.storageKey, JSON.stringify(usableStorage));
+      } catch (e) {
+        // Silent fail
+      }
+
+      return usableStorage;
+    },
+
+    remove: (path) => {
+      if (!path) {
+        this.session.clear();
+      } else {
+        this.session.set(path, undefined);
+      }
+    },
+
+    clear: () => {
+      try {
+        window.sessionStorage.setItem(this.storageKey, '{}');
+      } catch (e) {
+        // Silent fail
+      }
+    }
+  };
+}
+
+export default Storage;

package/dist/modules/triggers.js

@@ -0,0 +1,117 @@
+/**
+ * triggers — the ONE click-trigger registry every OMEGA surface shares
+ * ([#16](https://github.com/Omega-JS-Stack/omega/issues/16)).
+ *
+ * A trigger is markup wiring: a class on an element means "clicking this runs
+ * that action", with no per-page JS. Before this module every surface rolled
+ * its own delegated `document` click listener with its own naming convention
+ * (`.auth-signout-btn` in client, `.auth-signin-btn` in extension,
+ * `.uj-password-toggle` in web, twice). Now there is exactly ONE listener and
+ * exactly one naming rule:
+ *
+ *   registerTrigger('signout', handler)  →  the class is `omega-signout`
+ *
+ * The class is ALWAYS `omega-<name>` — callers never spell it, so it can never
+ * drift. A click anywhere inside a trigger element counts (closest()), which is
+ * what makes icon-only and label-wrapped buttons work.
+ *
+ * Who registers what: the client registers the GENERIC actions (sign-out), and
+ * each surface registers its own (extension: sign-in opens its auth page; web:
+ * the password eye). Registration is what arms the listener, so a surface can
+ * register before or after `omega.initialize()` — order never matters.
+ *
+ * Sibling of `motion` and `icon-renderer`: transport-free, DOM-only, and inert
+ * where there is no document (desktop main, the extension service worker).
+ */
+
+import { createLogger } from './logger.js';
+
+const logger = createLogger('triggers');
+
+// The one prefix. A trigger named `signout` is the class `omega-signout`.
+const PREFIX = 'omega-';
+
+// name → handler. Module-level because the registry IS the singleton: one
+// document, one listener, one table.
+const handlers = new Map();
+
+// True once the ONE delegated listener is attached.
+let listening = false;
+
+/**
+ * Attach the single delegated listener, once.
+ */
+function ensureListener() {
+  if (listening || typeof document === 'undefined') {
+    return;
+  }
+
+  listening = true;
+  document.addEventListener('click', handleClick);
+}
+
+/**
+ * The one delegated handler: find the innermost trigger element the click
+ * happened inside, then run every trigger that element carries.
+ * @param {Event} event
+ */
+function handleClick(event) {
+  if (!handlers.size) {
+    return;
+  }
+
+  // ONE closest() call over the union selector — the INNERMOST trigger wins,
+  // so nesting a trigger inside a trigger is deterministic.
+  const selector = [...handlers.keys()].map((name) => `.${PREFIX}${name}`).join(',');
+  const element = event.target?.closest?.(selector);
+
+  if (!element) {
+    return;
+  }
+
+  // A trigger class means the framework owns this click: no default navigation,
+  // no page-level handler behind it. Both legacy auth listeners did exactly
+  // this, and the markup contract is now the same everywhere.
+  event.preventDefault();
+  event.stopPropagation();
+
+  for (const [name, handler] of handlers) {
+    if (!element.classList.contains(`${PREFIX}${name}`)) {
+      continue;
+    }
+
+    // A throwing trigger is logged and never allowed to swallow the others.
+    // Async handlers (sign-out awaits Firebase) hand their failure back the
+    // same way.
+    try {
+      const result = handler(event, element);
+      if (typeof result?.catch === 'function') {
+        result.catch((error) => logger.error(`Trigger "${name}" failed:`, error));
+      }
+    } catch (error) {
+      logger.error(`Trigger "${name}" failed:`, error);
+    }
+  }
+}
+
+/**
+ * Register a click trigger. The class it answers to is always `omega-<name>`.
+ * Re-registering the same name REPLACES the handler (with a warning) — there is
+ * no stacking, so a hot reload or a double boot can never double-fire.
+ * @param {string} name - trigger name, e.g. 'signout'
+ * @param {Function} handler - called with (event, element)
+ */
+export function registerTrigger(name, handler) {
+  if (typeof handler !== 'function') {
+    throw new Error(`registerTrigger("${name}") needs a handler function`);
+  }
+
+  if (handlers.has(name)) {
+    logger.warn(`Trigger "${name}" re-registered — the new handler replaces the old one`);
+  }
+
+  handlers.set(name, handler);
+  ensureListener();
+}
+
+export default registerTrigger;