@omega.js/extension 0.1.0

package/dist/lib/affiliatizer.js

@@ -0,0 +1,224 @@
+// Suppported affiliates
+const map = [
+  // Amazon
+  {
+    id: 'amazon',
+    match: /amazon.com/,
+    replace: {
+      href: 'https://giftly.app/product?url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB07PCMWTSG%3F%26linkCode%3Dll2%26tag%3Ditwcw1--promo-server-20%26linkId%3D38af0d81784751e4cf5b1136b8c32f63%26language%3Den_US%26ref_%3Das_li_ss_tl',
+    },
+  },
+
+  // Meals
+  {
+    id: 'factor',
+    match: /factor75.com/,
+    replace: {
+      href: 'https://www.factor75.com/plans?c=HS-HC5E50S4I&discount_comm_id=cd2585e3-0672-4633-90a6-64f6883222a3&plans_ab=true&utm_campaign=clipboard&utm_medium=referral&utm_source=raf-share-hpt',
+    },
+  },
+
+  // Rewards
+  {
+    id: 'honeygain',
+    match: /honeygain.com/,
+    replace: {
+      href: 'https://r.honeygain.me/IANA1DCDB1',
+    },
+  },
+  {
+    id: 'jumptask',
+    match: /app.jumptask.io/,
+    replace: {
+      href: 'https://www.jumptask.io/r/dazelafojafy',
+    },
+  },
+  {
+    id: 'pawns',
+    match: /pawns.app/,
+    replace: {
+      href: 'https://pawns.app/?r=5798401',
+    },
+  },
+
+  // Shopping
+  {
+    id: 'capitaloneshopping',
+    match: /capitaloneshopping.com/,
+    replace: {
+      href: 'https://capitaloneshopping.com/r/5G2HF1D',
+    },
+  },
+  {
+    id: 'coupert',
+    match: /coupert.com/,
+    replace: {
+      href: 'https://www.coupert.com/invite/4yvqkp7da',
+    },
+  },
+  {
+    id: 'honey',
+    match: /joinhoney.com/,
+    replace: {
+      href: 'https://www.joinhoney.com/ref/8dryc8u',
+    },
+  },
+  {
+    id: 'lolli',
+    match: /lolli.com/,
+    replace: {
+      href: 'https://lolli.com/share/ydsPvyc23m',
+    },
+  },
+  {
+    id: 'paypal',
+    match: /paypal.com/,
+    replace: {
+      href: 'https://py.pl/4gPBBJjLbbz',
+    },
+  },
+  {
+    id: 'rakuten',
+    match: /rakuten.com/,
+    replace: {
+      href: 'https://www.rakuten.com/r/IANWIE8?eeid=28187',
+    },
+  },
+  {
+    id: 'upside',
+    match: /upside.com/,
+    replace: {
+      href: 'https://upside.app.link/IAN4447',
+    },
+  },
+
+  // VPN
+  {
+    id: 'nordvpn',
+    match: /nordvpn.com/,
+    replace: {
+      href: 'https://ref.nordvpn.com/CHMkfrnoQtL',
+    },
+  },
+];
+
+function Affiliatizer() {
+}
+
+Affiliatizer.get = function () {
+  return map;
+};
+
+Affiliatizer.initialize = async function (Manager) {
+  // Shortcuts
+  const { extension, logger } = Manager;
+  const storage = extension.storage.local;
+
+  // Parse the URL
+  const url = new URL(window.location.href);
+  const query = url.searchParams;
+
+  // Get query parameters
+  const qsStatus = query.get('affiliatizerStatus');
+
+  // Check if the URL has the affiliatizerStatus parameter
+  if (qsStatus === 'reset') {
+    // Log
+    logger.log('Resetting affiliatizer data...');
+
+    // Reset the data
+    await storage.set({ affiliatizer: null });
+    query.delete('affiliatizerStatus');
+
+    // Log
+    logger.log('Reset!');
+  } else if (qsStatus === 'block') {
+    // Log
+    logger.log('Affiliatizer is blocked.');
+
+    // Set affiliatizer to 'block' in storage
+    await storage.set({ affiliatizer: 'block' });
+  } else if (qsStatus === 'allow') {
+    // Log
+    logger.log('Affiliatizer is allowed.');
+
+    // Set affiliatizer to 'allow' in storage
+    await storage.set({ affiliatizer: 'allow' });
+  }
+
+  // Check if affiliatizer is blocked
+  const data = await storage.get() || {};
+  const status = data.affiliatizer || 'allow';
+
+  // Check if it's blocked
+  if (status === 'block') {
+    logger.log('Affiliatizer is blocked.');
+    return;
+  }
+
+  // Loop through the map
+  map.forEach((item, i) => {
+    // Get the item
+    const id = item.id;
+
+    // Log
+    // logger.log('Checking for', id, item.match, 'in', url.hostname, '...');
+
+    // Check if the item matches
+    if (!item.match.test(url.hostname)) {
+      return;
+    }
+
+    // Process
+    storage.get((data) => {
+      // Log
+      logger.log('Matched', data);
+
+      // Set the default data
+      const now = new Date();
+      const timestamp = new Date(data.affiliatizer && data.affiliatizer[id] ? data.affiliatizer[id].timestamp || 0 : 0);
+      const differenceInHours = (now - timestamp) / 1000 / 60 / 60;
+
+      // Check if the timestamp is older than 24 hours
+      if (differenceInHours < 24) {
+        return;
+      }
+
+      // Build the new URL
+      const newURL = new URL(url.href);
+
+      // Query
+      if (item.replace.query) {
+        Object.keys(item.replace.query).forEach((key, i) => {
+          newURL.searchParams.set(key, item.replace.query[key]);
+        });
+      }
+
+      // Path
+      if (item.replace.pathname) {
+        newURL.pathname = item.replace.pathname;
+      }
+
+      // Href
+      if (item.replace.href) {
+        newURL.href = item.replace.href;
+      }
+
+      // Log
+      logger.log('Redirecting...', newURL.toString());
+
+      // Save to storage
+      const newTimestamp = {
+        timestamp: now.toISOString(),
+      };
+      const updatedData = Object.assign({}, data.affiliatizer, { [id]: newTimestamp });
+      storage.set({ affiliatizer: updatedData });
+
+      // Redirect
+      window.location.href = newURL.toString();
+    });
+  });
+}
+
+// Export
+module.exports = Affiliatizer;

package/dist/lib/analytics.js

@@ -0,0 +1,26 @@
+// The extension's own lifecycle event ([#328](https://github.com/Omega-JS-Stack/omega/issues/328)
+// inventory gap 7: the extension counted nothing about ITSELF — the only signal
+// anywhere was `extension_install`, fired by the website's landing page).
+//
+// `app_launch` is the catalog's launch event, the same one desktop's main
+// process fires. Every context that boots @omega.js/client is a launch of a
+// surface — the toolbar popup, the side panel, the options page, an injected
+// page — and each carries its own session, so each counts one.
+//
+// Install tracking stays where it is: the web landing page owns
+// `extension_install`, deliberately (it is the page that knows a store visit
+// turned into an install).
+import omega from '@omega.js/client';
+
+/**
+ * Count this context's launch. Never throws at a boot: analytics is a side
+ * effect of the surface opening, not a condition of it.
+ * @returns {void}
+ */
+export function trackAppLaunch() {
+  try {
+    omega.analytics().event('app_launch');
+  } catch (e) {
+    // The client logs its own failures; a launch is not the place to raise.
+  }
+}

package/dist/lib/auth-helpers.js

@@ -0,0 +1,213 @@
+// Auth helpers for cross-context auth sync in browser extensions
+// Used by popup.js, options.js, sidepanel.js, page.js
+//
+// Architecture:
+// - Background.js is the SOURCE OF TRUTH for authentication
+// - On context load, contexts wait for @omega.js/client auth to settle, then ask background if in sync
+// - If out of sync, background provides a fresh custom token (fetched from server)
+// - No BXM-specific storage - Web Manager handles auth state internally
+
+import { registerTrigger } from '@omega.js/client/modules/triggers.js';
+import { WAKEUP_ROUTE } from '@omega.js/client/modules/request.js';
+import LoggerLite from './logger-lite.js';
+
+// The auth sub-modules of the identity tag — these lines are about auth, not
+// about whichever surface (popup/options/sidepanel/page) called in.
+const syncLogger = new LoggerLite('auth:sync');
+const broadcastLogger = new LoggerLite('auth:broadcast');
+
+/**
+ * Sync auth state with background.js on context load
+ * Waits for @omega.js/client auth to settle, then asks background if in sync
+ * @param {Object} context - The manager instance (must have extension, omega)
+ */
+export async function syncWithBackground(context) {
+  const { extension, omega } = context;
+
+  // Warm the backend before the auth wait below. When this sync needs a token,
+  // background answers it by POSTing `/omega/user/token` — the extension's
+  // first backend call, on a function that is cold on the first surface a user
+  // opens. Fire-and-forget and unauthenticated: the backend answers a wakeup
+  // before it loads a route or authenticates
+  // ([#644](https://github.com/Omega-JS-Stack/omega/issues/644)).
+  omega.request(WAKEUP_ROUTE, { wakeup: true });
+
+  try {
+    // Wait for @omega.js/client auth state to settle FIRST (prevents race conditions)
+    const localState = await new Promise(resolve => {
+      omega.auth().listen({ once: true }, resolve);
+    });
+
+    const localUid = localState.user?.uid || null;
+    syncLogger.log('Local auth state settled, UID:', localUid);
+
+    // Ask background for auth state comparison
+    const response = await new Promise((resolve) => {
+      extension.runtime.sendMessage(
+        { command: 'omega:syncAuth', contextUid: localUid },
+        (res) => {
+          if (extension.runtime.lastError) {
+            syncLogger.log('Background not ready:', extension.runtime.lastError.message);
+            resolve({ needsSync: false });
+            return;
+          }
+          resolve(res || { needsSync: false });
+        }
+      );
+    });
+
+    // Already in sync
+    if (!response.needsSync) {
+      syncLogger.log('Already in sync with background');
+      return;
+    }
+
+    // Need to sign out (background is signed out, context is signed in)
+    if (response.signOut) {
+      syncLogger.log('Background signed out, signing out context...');
+      await omega.auth().signOut();
+      return;
+    }
+
+    // Need to sign in with token
+    if (response.customToken) {
+      syncLogger.log('Syncing with background...', response.user?.email);
+      await omega.auth().signInWithCustomToken(response.customToken);
+      syncLogger.log('Synced successfully');
+    }
+
+  } catch (error) {
+    syncLogger.error('Error syncing with background:', error.message);
+  }
+}
+
+/**
+ * Set up listener for auth token broadcasts from background.js
+ * Handles both sign-in broadcasts and sign-out broadcasts
+ * @param {Object} context - The manager instance (must have extension, omega)
+ */
+export function setupAuthBroadcastListener(context) {
+  const { omega } = context;
+
+  // Listen for messages from service worker (background.js)
+  navigator.serviceWorker?.addEventListener('message', async (event) => {
+    const { command, token } = event.data || {};
+
+    // Handle sign-in broadcast
+    if (command === 'omega:signInWithToken' && token) {
+      broadcastLogger.log('Received sign-in broadcast');
+      try {
+        await omega.auth().signInWithCustomToken(token);
+        broadcastLogger.log('Signed in via broadcast');
+      } catch (error) {
+        broadcastLogger.error('Error signing in:', error.message);
+      }
+      return;
+    }
+
+    // Handle sign-out broadcast
+    if (command === 'omega:signOut') {
+      // Skip if already signed out (prevents loops)
+      if (!omega.auth().getUser()) {
+        broadcastLogger.log('Already signed out, ignoring broadcast');
+        return;
+      }
+      broadcastLogger.log('Received sign-out broadcast');
+      try {
+        await omega.auth().signOut();
+        broadcastLogger.log('Signed out via broadcast');
+      } catch (error) {
+        broadcastLogger.error('Error signing out:', error.message);
+      }
+    }
+  });
+
+  broadcastLogger.log('Broadcast listener set up');
+}
+
+/**
+ * Set up listener to notify background when user signs out from this context
+ * @param {Object} context - The manager instance (must have extension, omega)
+ */
+export function setupSignOutListener(context) {
+  const { extension, omega } = context;
+
+  // Track previous user to detect sign-out
+  let previousUid = null;
+
+  omega.auth().listen((state) => {
+    const currentUid = state.user?.uid || null;
+
+    // Detect sign-out (had user, now don't)
+    if (previousUid && !currentUid) {
+      syncLogger.log('Detected sign-out, notifying background...');
+      extension.runtime.sendMessage({ command: 'omega:signOut' });
+    }
+
+    previousUid = currentUid;
+  });
+
+  syncLogger.log('Sign-out listener set up');
+}
+
+/**
+ * Open auth page in new tab (for signing in via website)
+ * @param {Object} context - The manager instance (must have extension, omega, logger)
+ * @param {Object} options - Options object
+ * @param {string} options.path - Path to open (default: '/token')
+ * @param {string} options.authReturnUrl - Return URL for electron/deep links
+ */
+export function openAuthPage(context, options = {}) {
+  const { extension, omega, logger } = context;
+
+  // The /token page lives on the BRAND site (wave-5 F9) — background.js
+  // watches the same brand.url host for the redirect. Never authDomain:
+  // it is an auth concern that must stay free to change independently.
+  const brandUrl = omega.config?.brand?.url;
+
+  if (!brandUrl) {
+    logger.error('No brand.url configured');
+    return;
+  }
+
+  // Build the URL
+  const path = options.path || '/token';
+  const authUrl = new URL(path, brandUrl);
+
+  // Add return URL if provided (for electron/deep links)
+  if (options.authReturnUrl) {
+    authUrl.searchParams.set('authReturnUrl', options.authReturnUrl);
+  }
+
+  // Log
+  logger.log('Opening auth page:', authUrl.toString());
+
+  // Get current active tab so we can restore it after auth
+  extension.tabs.query({ active: true, currentWindow: true }, (tabs) => {
+    const authSourceTabId = tabs[0]?.id;
+
+    // Add source tab ID to URL so background can restore it
+    if (authSourceTabId) {
+      authUrl.searchParams.set('authSourceTabId', authSourceTabId);
+    }
+
+    // Open in new tab
+    extension.tabs.create({ url: authUrl.toString() });
+  });
+}
+
+/**
+ * Register the extension's own auth triggers on the shared click-trigger
+ * registry (#16). `omega-signin` and `omega-account` are surface-specific — only
+ * an extension opens a brand page in a new tab — so the extension owns them
+ * here; `omega-signout` comes from @omega.js/client (setupSignOutListener
+ * detects the sign-out and notifies background).
+ * @param {Object} context - The manager instance (must have extension, omega, logger)
+ */
+export function setupAuthEventListeners(context) {
+  registerTrigger('signin', () => openAuthPage(context));
+  registerTrigger('account', () => openAuthPage(context, { path: '/account' }));
+
+  // Log
+  context.logger.log('Auth event listeners set up');
+}

package/dist/lib/extension.js

@@ -0,0 +1,116 @@
+// APIs
+const apis = [
+  'action',
+  'alarms',
+  'bookmarks',
+  'browsingData',
+  'browserAction',
+  'certificateProvider',
+  'commands',
+  'contentSettings',
+  'contextMenus',
+  'cookies',
+  'debugger',
+  'declarativeContent',
+  'declarativeNetRequest',
+  'devtools',
+  'dns',
+  'documentScan',
+  'downloads',
+  'enterprise',
+  'events',
+  'extension',
+  'extensionTypes',
+  'fileBrowserHandler',
+  'fileSystemProvider',
+  'fontSettings',
+  'gcm',
+  'history',
+  'i18n',
+  'identity',
+  'idle',
+  'input',
+  'instanceID',
+  'management',
+  'notifications',
+  'offscreen',
+  'omnibox',
+  'pageAction',
+  'permissions',
+  'platformKeys',
+  'power',
+  'printerProvider',
+  'privacy',
+  'proxy',
+  'runtime',
+  'scripting',
+  'search',
+  'sessions',
+  'sidePanel',
+  'storage',
+  'tabGroups',
+  'tabs',
+  'topSites',
+  'tts',
+  'ttsEngine',
+  'userScripts',
+  'vpnProvider',
+  'wallpaper',
+  'webNavigation',
+  'webRequest',
+  'windows'
+]
+
+// Class
+function Extension () {
+  const self = this;
+
+  // Loop through the APIs and assign them to the object
+  apis.forEach(function (api) {
+    // Initialize the API to null
+    self[api] = null;
+
+    // Try chrome
+    try {
+      if (chrome[api]) {
+        self[api] = chrome[api];
+      }
+    } catch (e) {}
+
+    // Try browser (Firefox)
+    try {
+      if (!self[api] && browser[api]) {
+        self[api] = browser[api];
+      }
+    } catch (e) {}
+
+    // Try browser.extension (legacy Firefox surface)
+    // NEVER probe window[api]: DOM globals like window.history would shadow
+    // the chrome API of the same name in popup/options/content contexts.
+    try {
+      if (!self[api] && browser.extension[api]) {
+        self[api] = browser.extension[api];
+      }
+    } catch (e) {}
+  })
+
+  // Try to get the runtime
+  try {
+    if (browser && browser.runtime) {
+      self.runtime = browser.runtime
+    }
+  } catch (e) {}
+
+  // Try to get the browserAction
+  try {
+    if (browser && browser.browserAction) {
+      self.browserAction = browser.browserAction
+    }
+  } catch (e) {}
+
+  // Return the object
+  return self;
+}
+
+// Export
+module.exports = new Extension();

package/dist/lib/icons.js

@@ -0,0 +1,36 @@
+/**
+ * Extension-page icon auto-render (C4 cp112) — importing this module wires
+ * the SAME shared watcher web and desktop run (@omega.js/client's
+ * icon-renderer): plain fa-* markup, static or set/changed via JS, renders
+ * inline SVGs. The extension's transport is its own packaged set —
+ * dist/assets/icons/, emitted at build (gulp `fontawesome` task), fetched via
+ * chrome.runtime.getURL, fully offline.
+ *
+ * Side-effect import, one line per page surface (popup/options/sidepanel/
+ * page):  import './lib/icons.js';
+ *
+ * Content scripts deliberately do NOT auto-wire: watching a HOST page's
+ * whole DOM would collide with sites that use Font Awesome themselves.
+ * Injected UI can import { createIconRenderer } and scan() its own
+ * container (assets/icons/* is web-accessible for exactly this).
+ */
+import { createIconRenderer } from '@omega.js/client/modules/icon-renderer.js';
+import { ICONS_DIR, candidateRelPaths } from '@omega.js/client/modules/icon-core.js';
+
+if (typeof chrome !== 'undefined' && chrome.runtime?.getURL && typeof document !== 'undefined') {
+  createIconRenderer({
+    // icon-core's candidate order — the requested style, then `brands/` — so
+    // `<i class="fa-solid fa-github">` renders here exactly as it does on web
+    // and desktop. Sequential by definition: brands/ is only ever asked for
+    // when the requested style dir has no such file.
+    resolve: async (name, style) => {
+      for (const rel of candidateRelPaths(name, style)) {
+        const response = await fetch(chrome.runtime.getURL(`assets/${ICONS_DIR}/${rel}`));
+        if (response.ok) return response.text();
+      }
+      return null;
+    },
+  }).start(document);
+}
+
+export { createIconRenderer };

package/dist/lib/logger-lite.js

@@ -0,0 +1,35 @@
+// Runtime logger — the extension's own lineage (service worker, popup, options,
+// content scripts). Prints the ONE identity tag, `[@omega.js/extension:<name>]`,
+// with NO timestamp: devtools stamps runtime lines already
+// ([#12](https://github.com/Omega-JS-Stack/omega/issues/12)). The build-time twin
+// (lib/logger.js → @omega.js/devkit/logger) is the one that prefixes [HH:MM:SS].
+
+// Libraries
+
+// The package segment — this file IS @omega.js/extension, so it is a literal.
+const PACKAGE = '@omega.js/extension';
+
+// Logger class
+function Logger(name) {
+  const self = this;
+
+  // Properties
+  self.name = name;
+}
+
+// Loop through log, error, warn, info, and debug and make methods that log to console with the tag [@omega.js/extension:name] message
+// Setup logger
+['log', 'error', 'warn', 'info', 'debug'].forEach(method => {
+  Logger.prototype[method] = function () {
+    const self = this;
+
+    // Add prefix
+    const args = [`[${PACKAGE}:${self.name}]`, ...Array.from(arguments)];
+
+    // Call the original console method
+    console[method].apply(console, args);
+  };
+});
+
+// Export
+module.exports = Logger;

package/dist/lib/logger.js

@@ -0,0 +1,4 @@
+// Shared devkit module — vendored into dist/vendor/devkit at prepare time by the
+// preparePackage `after` hook. This shim keeps the framework's internal require
+// paths stable while the implementation lives in @omega.js/devkit.
+module.exports = require('../vendor/devkit/logger.js');