nowaikit-utils 1.1.0

package/content/content.js

@@ -0,0 +1,2527 @@
+/**
+ * NowAIKit Utils — Content Script
+ *
+ * Injected into ServiceNow pages. Provides:
+ * - Technical name resolver (show field names on hover)
+ * - Update set indicator banner
+ * - Field type tooltips (with sys_dictionary metadata)
+ * - Quick copy sys_id / field values
+ * - Node switcher (cookie + performance API detection)
+ * - Script syntax highlighting in script fields
+ * - Quick navigation shortcuts
+ * - Record info overlay
+ * - Theme detection (Polaris dark/light)
+ */
+
+(function() {
+  'use strict';
+
+  // ─── Iframe Detection (early — used to skip heavy work in iframes) ────────
+  var isIframe = window !== window.top;
+
+  // ─── Shared State Namespace ─────────────────────────────────────────────────
+  // Exposed on window so ai-sidebar.js, code-templates.js, etc. can access
+  window.nowaikitState = window.nowaikitState || {
+    currentTable: '',
+    currentSysId: '',
+    instanceUrl: '',
+    isForm: false,
+    isList: false,
+    isMac: /Mac|iPod|iPhone|iPad/.test(navigator.platform || navigator.userAgent),
+  };
+  var NS = window.nowaikitState;
+
+  // ─── Settings ───────────────────────────────────────────────────────────────
+
+  let settings = {
+    showTechnicalNames: false,
+    showUpdateSetBanner: false,
+    showFieldTypes: false,
+    enableNodeSwitcher: false,
+    enableQuickNav: false,
+    enableScriptHighlight: false,
+    enableFieldCopy: false,
+    enableAISidebar: false,
+    darkOverlay: false,
+  };
+
+  // One-time migration: force all features off for users who had old defaults
+  // Only run in top frame — iframes don't need to repeat this
+  if (!isIframe) {
+    chrome.storage.sync.get({ _defaultsV2Migrated: false }, function(m) {
+      if (!m._defaultsV2Migrated) {
+        chrome.storage.sync.set({
+          showTechnicalNames: false,
+          showUpdateSetBanner: false,
+          showFieldTypes: false,
+          enableNodeSwitcher: false,
+          enableQuickNav: false,
+          enableScriptHighlight: false,
+          enableFieldCopy: false,
+          enableAISidebar: false,
+          _defaultsV2Migrated: true,
+        });
+      }
+    });
+  }
+
+  // Load settings and init
+  if (isIframe) {
+    // In iframes, read settings directly from storage — skip service worker round-trip
+    chrome.storage.sync.get(settings, function(stored) {
+      if (chrome.runtime.lastError) {
+        // Storage access failed — init with defaults (all features off)
+      } else if (stored) {
+        settings = stored;
+      }
+      init();
+    });
+  } else {
+    // Top frame: load via service worker (supports richer settings pipeline)
+    try {
+      chrome.runtime.sendMessage({ action: 'getSettings' }, (response) => {
+        if (chrome.runtime.lastError) {
+          console.warn('NowAIKit Utils: Settings load failed, using defaults');
+        } else if (response) {
+          settings = response;
+        }
+        init();
+      });
+    } catch (e) {
+      // Service worker completely unavailable — init with defaults
+      console.warn('NowAIKit Utils: Service worker unavailable, using defaults');
+      init();
+    }
+  }
+
+  // ─── State (local aliases — also synced to NS) ────────────────────────────
+
+  let currentTable = '';
+  let currentSysId = '';
+  let instanceUrl = '';
+  let isForm = false;
+  let isList = false;
+
+  /** @type {Object<string, Object[]>} Cache of sys_dictionary metadata keyed by table name */
+  const fieldMetadataCache = {};
+
+  // ─── 3A. MutationObserver Utility ─────────────────────────────────────────
+
+  /**
+   * Waits for an element matching `selector` to appear in the DOM.
+   * Uses MutationObserver for reliable, fast detection instead of setTimeout.
+   *
+   * @param {string} selector - CSS selector to watch for
+   * @param {function} callback - Called with the first matched element
+   * @param {number} [timeout=10000] - Max wait time in ms before giving up
+   * @returns {function} Dispose function to cancel the observer early
+   */
+  function waitForElement(selector, callback, timeout) {
+    if (timeout === undefined) timeout = 10000;
+
+    // Check if element already exists
+    const existing = document.querySelector(selector);
+    if (existing) {
+      callback(existing);
+      return function() {};
+    }
+
+    let disposed = false;
+    let timer = null;
+
+    const observer = new MutationObserver(function() {
+      if (disposed) return;
+      const el = document.querySelector(selector);
+      if (el) {
+        disposed = true;
+        observer.disconnect();
+        if (timer) clearTimeout(timer);
+        callback(el);
+      }
+    });
+
+    observer.observe(document.body || document.documentElement, {
+      childList: true,
+      subtree: true,
+    });
+
+    if (timeout > 0) {
+      timer = setTimeout(function() {
+        if (!disposed) {
+          disposed = true;
+          observer.disconnect();
+        }
+      }, timeout);
+    }
+
+    return function() {
+      if (!disposed) {
+        disposed = true;
+        observer.disconnect();
+        if (timer) clearTimeout(timer);
+      }
+    };
+  }
+
+  /**
+   * Waits for all elements matching `selector` to stabilize (no new matches
+   * for `debounceMs`), then calls callback with the NodeList.
+   *
+   * @param {string} selector - CSS selector
+   * @param {function} callback - Called with querySelectorAll results
+   * @param {number} [timeout=10000] - Max wait in ms
+   * @param {number} [debounceMs=500] - Debounce interval
+   * @returns {function} Dispose function
+   */
+  function waitForElements(selector, callback, timeout, debounceMs) {
+    if (timeout === undefined) timeout = 10000;
+    if (debounceMs === undefined) debounceMs = 500;
+
+    const existing = document.querySelectorAll(selector);
+    if (existing.length > 0) {
+      // Still observe briefly in case more are loading
+      let settled = false;
+      let debounceTimer = null;
+      let disposed = false;
+
+      const observer = new MutationObserver(function() {
+        if (disposed) return;
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(function() {
+          if (!disposed) {
+            disposed = true;
+            observer.disconnect();
+            callback(document.querySelectorAll(selector));
+          }
+        }, debounceMs);
+      });
+
+      observer.observe(document.body || document.documentElement, {
+        childList: true,
+        subtree: true,
+      });
+
+      // Trigger initial debounce
+      debounceTimer = setTimeout(function() {
+        if (!disposed) {
+          disposed = true;
+          observer.disconnect();
+          callback(document.querySelectorAll(selector));
+        }
+      }, debounceMs);
+
+      const maxTimer = setTimeout(function() {
+        if (!disposed) {
+          disposed = true;
+          observer.disconnect();
+          if (debounceTimer) clearTimeout(debounceTimer);
+          callback(document.querySelectorAll(selector));
+        }
+      }, timeout);
+
+      return function() {
+        if (!disposed) {
+          disposed = true;
+          observer.disconnect();
+          if (debounceTimer) clearTimeout(debounceTimer);
+          clearTimeout(maxTimer);
+        }
+      };
+    }
+
+    // Nothing found yet — watch until something appears, then debounce
+    let disposed = false;
+    let debounceTimer = null;
+
+    const observer = new MutationObserver(function() {
+      if (disposed) return;
+      const els = document.querySelectorAll(selector);
+      if (els.length > 0) {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(function() {
+          if (!disposed) {
+            disposed = true;
+            observer.disconnect();
+            callback(document.querySelectorAll(selector));
+          }
+        }, debounceMs);
+      }
+    });
+
+    observer.observe(document.body || document.documentElement, {
+      childList: true,
+      subtree: true,
+    });
+
+    const maxTimer = setTimeout(function() {
+      if (!disposed) {
+        disposed = true;
+        observer.disconnect();
+        if (debounceTimer) clearTimeout(debounceTimer);
+        const els = document.querySelectorAll(selector);
+        if (els.length > 0) callback(els);
+      }
+    }, timeout);
+
+    return function() {
+      if (!disposed) {
+        disposed = true;
+        observer.disconnect();
+        if (debounceTimer) clearTimeout(debounceTimer);
+        clearTimeout(maxTimer);
+      }
+    };
+  }
+
+  // ─── Workspace / SPA Detection ──────────────────────────────────────────────
+
+  /** True if we're on a workspace / Next Experience / Polaris route */
+  let isWorkspace = false;
+  let lastUrl = '';
+
+  function detectWorkspace() {
+    const url = window.location.href;
+    isWorkspace = /\/now\/(sow|workspace|nav\/ui|agent)/.test(url) ||
+                  !!document.querySelector('sn-polaris-layout, macroponent-f51912f4, now-record-form, [data-component="sn-polaris-header"]');
+    NS.isWorkspace = isWorkspace;
+  }
+
+  /**
+   * Observe workspace SPA navigation — re-run feature injection when the
+   * route changes without a full page reload.
+   */
+  function watchSpaNavigation() {
+    lastUrl = window.location.href;
+
+    // Method 1: popstate for back/forward
+    window.addEventListener('popstate', onRouteChange);
+
+    // Method 2: Intercept pushState/replaceState (with guard to prevent double-patching)
+    if (!history._nowaikitPatched) {
+      const origPush = history.pushState;
+      const origReplace = history.replaceState;
+      history.pushState = function() {
+        origPush.apply(this, arguments);
+        onRouteChange();
+      };
+      history.replaceState = function() {
+        origReplace.apply(this, arguments);
+        onRouteChange();
+      };
+      history._nowaikitPatched = true;
+    }
+
+    // Method 3: DOM mutation fallback for frameworks that bypass history API
+    var urlCheckTimer = setInterval(function() {
+      if (window.location.href !== lastUrl) {
+        onRouteChange();
+      }
+    }, 1500);
+  }
+
+  function onRouteChange() {
+    var newUrl = window.location.href;
+    if (newUrl === lastUrl) return;
+    lastUrl = newUrl;
+
+    // Re-detect page state
+    currentTable = '';
+    currentSysId = '';
+    isForm = false;
+    isList = false;
+    detectPage();
+    detectWorkspace();
+
+    NS.currentTable = currentTable;
+    NS.currentSysId = currentSysId;
+    NS.isForm = isForm;
+    NS.isList = isList;
+
+    // Re-inject features after a short delay (let the SPA render)
+    setTimeout(injectFeatures, 600);
+  }
+
+  // ─── Initialization ─────────────────────────────────────────────────────────
+
+  function init() {
+    detectPage();
+    if (!instanceUrl) return; // Not a ServiceNow page
+    detectWorkspace();
+
+    // Sync state to shared namespace for other scripts (ai-sidebar, etc.)
+    NS.currentTable = currentTable;
+    NS.currentSysId = currentSysId;
+    NS.instanceUrl = instanceUrl;
+    NS.isForm = isForm;
+    NS.isList = isList;
+
+    // ─── Background Script Auto-Paste ─────────────────────────────────────────
+    // When "Run in BG Script" is clicked from templates, code is stored and
+    // sys.scripts.do is opened. Detect that page and inject the code.
+    if (window.location.pathname === '/sys.scripts.do' || window.location.pathname === '/sys.scripts.modern.do' || (window.location.pathname === '/nav_to.do' && window.location.search.indexOf('sys.scripts.do') !== -1)) {
+      chrome.storage.local.get({ nowaikitPendingScript: '' }, function(data) {
+        var pendingScript = data.nowaikitPendingScript;
+        if (!pendingScript) return;
+        // Clear immediately so it doesn't re-inject on refresh
+        chrome.storage.local.remove('nowaikitPendingScript');
+        // Wait for the page editor to load, then inject
+        var attempts = 0;
+        var injectTimer = setInterval(function() {
+          attempts++;
+          if (attempts > 40) { clearInterval(injectTimer); return; } // Give up after 8s
+          // Try CodeMirror first
+          var cmEl = document.querySelector('.CodeMirror');
+          if (cmEl && cmEl.CodeMirror) {
+            cmEl.CodeMirror.setValue(pendingScript);
+            clearInterval(injectTimer);
+            return;
+          }
+          // Try textarea
+          var ta = document.querySelector('textarea[name="script"]') || document.querySelector('#runscript');
+          if (ta) {
+            ta.value = pendingScript;
+            ta.dispatchEvent(new Event('input', { bubbles: true }));
+            clearInterval(injectTimer);
+            return;
+          }
+        }, 200);
+      });
+    }
+
+    // ─── Global Theme ─────────────────────────────────────────────────────────
+    // Apply stored theme to body so all extension UI respects dark/light mode.
+    // Runs in both top frame and iframes (tech names, badges use theme classes).
+    chrome.storage.local.get({ nowaikitTheme: 'dark' }, function(data) {
+      var theme = data.nowaikitTheme || 'dark';
+      document.body.classList.remove('nowaikit-light', 'nowaikit-dark');
+      document.body.classList.add('nowaikit-' + theme);
+    });
+
+    // Expose global theme API for other scripts (ai-sidebar, templates, etc.)
+    if (!isIframe) {
+      window.nowaikitGetTheme = function() {
+        return document.body.classList.contains('nowaikit-light') ? 'light' : 'dark';
+      };
+      window.nowaikitSetTheme = function(theme) {
+        document.body.classList.remove('nowaikit-light', 'nowaikit-dark');
+        document.body.classList.add('nowaikit-' + theme);
+        chrome.storage.local.set({ nowaikitTheme: theme });
+      };
+      window.nowaikitToggleTheme = function() {
+        var current = document.body.classList.contains('nowaikit-light') ? 'light' : 'dark';
+        var next = current === 'dark' ? 'light' : 'dark';
+        window.nowaikitSetTheme(next);
+        return next;
+      };
+    }
+
+    // Check if ANY feature is enabled — skip heavy init if all off
+    var anyFeatureOn = settings.showTechnicalNames || settings.showUpdateSetBanner ||
+      settings.showFieldTypes || settings.enableNodeSwitcher || settings.enableQuickNav ||
+      settings.enableScriptHighlight || settings.enableFieldCopy || settings.enableAISidebar;
+
+    // Always register keyboard shortcuts and context menu (lightweight, no DOM observers)
+    if (!isIframe) {
+      listenForContextMenuActions();
+      injectKeyboardShortcuts();
+    }
+
+    if (!anyFeatureOn) {
+      return;
+    }
+
+    // Inject g_ck bridge only when features need API calls
+    injectGckBridge();
+
+    detectTheme();
+    injectFeatures();
+
+    // These features only make sense in the top frame — not inside classic-in-iframe
+    if (!isIframe) {
+      injectInfoOverlay();
+
+      // Workspace-only: SPA navigation watcher + form mutation observer
+      if (isWorkspace) {
+        watchSpaNavigation();
+        watchWorkspaceForms();
+      }
+
+      // AI Sidebar — initialize if enabled and the function exists
+      if (settings.enableAISidebar && typeof initAISidebar === 'function') {
+        initAISidebar();
+      }
+    }
+  }
+
+  /** Inject all toggleable features (called on init and on SPA navigation) */
+  function injectFeatures() {
+    if (settings.showUpdateSetBanner) injectUpdateSetBanner();
+    if (settings.showTechnicalNames) injectTechnicalNames();
+    if (settings.enableFieldCopy) injectFieldCopy();
+    if (settings.enableQuickNav) injectQuickNav();
+    if (settings.enableScriptHighlight) injectScriptHighlighting();
+    if (settings.showFieldTypes) injectFieldTypeTooltips();
+  }
+
+  /**
+   * Watch for workspace form fields to appear after SPA render.
+   * Workspace/Polaris renders forms asynchronously — fields appear after
+   * the initial page shell loads. This observer triggers re-injection
+   * when new form fields are detected.
+   */
+  var _wsFormObserver = null;
+  function watchWorkspaceForms() {
+    if (_wsFormObserver) return; // Only one observer
+
+    var debounceTimer = null;
+    _wsFormObserver = new MutationObserver(function(mutations) {
+      // Check if any new form-related elements were added
+      var hasFormContent = false;
+      for (var i = 0; i < mutations.length; i++) {
+        var addedNodes = mutations[i].addedNodes;
+        for (var j = 0; j < addedNodes.length; j++) {
+          var node = addedNodes[j];
+          if (node.nodeType !== 1) continue;
+          if (node.matches && (
+            node.matches('sn-form-field, now-record-form, [data-field-name], .form-group') ||
+            node.querySelector && node.querySelector('sn-form-field, now-record-form, [data-field-name], .form-group, label')
+          )) {
+            hasFormContent = true;
+            break;
+          }
+        }
+        if (hasFormContent) break;
+      }
+
+      if (hasFormContent) {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(function() {
+          // Re-detect page state in case context changed
+          detectPage();
+          NS.currentTable = currentTable;
+          NS.currentSysId = currentSysId;
+          NS.isForm = isForm;
+
+          if (settings.showTechnicalNames) injectTechnicalNames();
+          if (settings.enableFieldCopy) injectFieldCopy();
+          if (settings.showFieldTypes) injectFieldTypeTooltips();
+        }, 1500);
+      }
+    });
+
+    // Only observe workspace pages — classic UI doesn't need this
+    if (!isWorkspace) return;
+
+    _wsFormObserver.observe(document.body || document.documentElement, {
+      childList: true,
+      subtree: true,
+    });
+  }
+
+  function detectPage() {
+    const url = window.location.href;
+    instanceUrl = window.location.origin;
+
+    // Method 1: Classic form — table.do with sys_id anywhere in query string
+    const doMatch = url.match(/\/([a-z_][a-z0-9_]*)\.do(?:\?|#|$)/);
+    if (doMatch) {
+      currentTable = doMatch[1];
+      // Look for sys_id anywhere in the query string (not just first param)
+      const sysIdMatch = url.match(/[?&]sys_id=([a-f0-9]{32})/);
+      if (sysIdMatch) {
+        currentSysId = sysIdMatch[1];
+        isForm = true;
+      }
+    }
+
+    // Method 2: Classic list — table_list.do
+    if (!isForm) {
+      const listMatch = url.match(/\/([a-z_][a-z0-9_]*)_list\.do/);
+      if (listMatch) {
+        currentTable = listMatch[1];
+        isList = true;
+      }
+    }
+
+    // Method 3: Next Experience navigation (classic UI in iframe)
+    if (!currentTable) {
+      const nxMatch = url.match(/\/now\/nav\/ui\/classic\/params\/target\/([a-z_][a-z0-9_]*)/);
+      if (nxMatch) {
+        currentTable = nxMatch[1];
+        // Try to find sys_id in encoded params
+        const nxSysId = url.match(/sys_id(?:%3D|=)([a-f0-9]{32})/i);
+        if (nxSysId) {
+          currentSysId = nxSysId[1];
+          isForm = true;
+        }
+      }
+    }
+
+    // Method 4: Workspace record view (/now/sow/record/table/sys_id or /now/workspace/...)
+    if (!currentTable) {
+      const wsMatch = url.match(/\/now\/(?:sow|workspace|agent)[^/]*\/(?:.*\/)?record\/([a-z_][a-z0-9_]*)\/([a-f0-9]{32})/);
+      if (wsMatch) {
+        currentTable = wsMatch[1];
+        currentSysId = wsMatch[2];
+        isForm = true;
+      }
+    }
+
+    // Method 5: Workspace list view (/now/workspace/.../list/table)
+    if (!currentTable) {
+      const wsListMatch = url.match(/\/now\/(?:sow|workspace|agent)[^/]*\/(?:.*\/)?list\/([a-z_][a-z0-9_]*)/);
+      if (wsListMatch) {
+        currentTable = wsListMatch[1];
+        isList = true;
+      }
+    }
+
+    // Method 6: Try to detect from GlideForm if available (classic UI)
+    if (!currentTable && typeof g_form !== 'undefined') {
+      try {
+        currentTable = g_form.getTableName();
+        currentSysId = g_form.getUniqueValue();
+        isForm = true;
+      } catch(e) { /* ignore */ }
+    }
+
+    // Method 7: Detect from DOM data attributes (workspace forms)
+    if (!currentTable) {
+      var formEl = document.querySelector('now-record-form[table], [data-table-name]');
+      if (formEl) {
+        currentTable = formEl.getAttribute('table') || formEl.getAttribute('data-table-name') || '';
+        var sysIdAttr = formEl.getAttribute('sys-id') || formEl.getAttribute('data-sys-id') || '';
+        if (sysIdAttr && /^[a-f0-9]{32}$/.test(sysIdAttr)) {
+          currentSysId = sysIdAttr;
+          isForm = true;
+        }
+      }
+    }
+  }
+
+  // ─── 3E. Theme Detection ──────────────────────────────────────────────────
+
+  let themeObserverActive = false;
+
+  function applyThemeClass() {
+    let isDark = false;
+
+    // Method 1: Polaris theme uses data-theme attribute
+    const htmlEl = document.documentElement;
+    const dataTheme = htmlEl.getAttribute('data-theme') || '';
+    if (dataTheme.includes('dark')) {
+      isDark = true;
+    } else if (dataTheme.includes('light')) {
+      isDark = false;
+    }
+
+    // Method 2: Check body classes used by newer Polaris builds
+    const bodyClasses = document.body ? document.body.className : '';
+    if (!dataTheme) {
+      if (bodyClasses.includes('navpage-theme-dark') || bodyClasses.includes('dark-theme') || bodyClasses.includes('sn-polaris-dark')) {
+        isDark = true;
+      }
+    }
+
+    // Method 3: Check CSS custom property set by Polaris
+    if (!dataTheme && !isDark) {
+      const bgColor = getComputedStyle(document.documentElement).getPropertyValue('--now-color--background--primary');
+      if (bgColor) {
+        // Parse the background color — dark themes have low luminance
+        const temp = document.createElement('div');
+        temp.style.color = bgColor.trim();
+        document.body.appendChild(temp);
+        const computed = getComputedStyle(temp).color;
+        document.body.removeChild(temp);
+        const rgb = computed.match(/\d+/g);
+        if (rgb && rgb.length >= 3) {
+          const luminance = (0.299 * parseInt(rgb[0]) + 0.587 * parseInt(rgb[1]) + 0.114 * parseInt(rgb[2])) / 255;
+          isDark = luminance < 0.5;
+        }
+      }
+    }
+
+    // Method 4: Fallback — check background color of body
+    if (!dataTheme && document.body) {
+      const bodyBg = getComputedStyle(document.body).backgroundColor;
+      if (bodyBg && bodyBg !== 'rgba(0, 0, 0, 0)') {
+        const rgb = bodyBg.match(/\d+/g);
+        if (rgb && rgb.length >= 3) {
+          const luminance = (0.299 * parseInt(rgb[0]) + 0.587 * parseInt(rgb[1]) + 0.114 * parseInt(rgb[2])) / 255;
+          if (luminance < 0.4) isDark = true;
+        }
+      }
+    }
+
+    // Apply theme classes
+    document.body.classList.remove('nowaikit-light', 'nowaikit-dark');
+    document.body.classList.add(isDark ? 'nowaikit-dark' : 'nowaikit-light');
+  }
+
+  function detectTheme() {
+    applyThemeClass();
+
+    // Set up a single observer (only once) to re-check when theme attributes change
+    if (!themeObserverActive) {
+      themeObserverActive = true;
+      const themeObserver = new MutationObserver(function(mutations) {
+        for (const m of mutations) {
+          if (m.type === 'attributes' && (m.attributeName === 'data-theme' || m.attributeName === 'class')) {
+            applyThemeClass();
+            break;
+          }
+        }
+      });
+      themeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme', 'class'] });
+      if (document.body) {
+        themeObserver.observe(document.body, { attributes: true, attributeFilter: ['class'] });
+      }
+    }
+  }
+
+  // ─── Update Set Banner ──────────────────────────────────────────────────────
+
+  function injectUpdateSetBanner() {
+    // Don't duplicate
+    if (document.getElementById('nowaikit-updateset-banner')) {
+      // On SPA nav, just re-fetch the update set name
+      fetchUpdateSetName(function(usName) {
+        var textEl = document.getElementById('nowaikit-us-text');
+        if (textEl && usName) {
+          textEl.innerHTML = '<strong>Update Set:</strong> ' + escapeHtml(usName);
+        }
+      });
+      return;
+    }
+
+    // Only inject on forms/lists/workspace
+    if (!isForm && !isList && !isWorkspace) return;
+
+    var banner = document.createElement('div');
+    banner.id = 'nowaikit-updateset-banner';
+    banner.innerHTML = '<span id="nowaikit-us-text">Loading update set...</span>';
+    document.body.prepend(banner);
+
+    fetchUpdateSetName(function(usName) {
+      if (usName) {
+        var textEl = document.getElementById('nowaikit-us-text');
+        if (textEl) {
+          textEl.innerHTML = '<strong>Update Set:</strong> ' + escapeHtml(usName);
+        }
+      } else {
+        banner.style.display = 'none';
+      }
+    });
+  }
+
+  /**
+   * Get the current update set name — works on both classic UI and workspace.
+   * Strategy: DOM picker first, then REST API fallback.
+   */
+  function fetchUpdateSetName(callback) {
+    // Strategy 1: Classic UI picker in DOM
+    var usPicker = document.querySelector('#update_set_picker_select');
+    if (usPicker && usPicker.options && usPicker.options[usPicker.selectedIndex]) {
+      callback(usPicker.options[usPicker.selectedIndex].text);
+      return;
+    }
+
+    // Strategy 2: Classic system info text
+    var sysInfo = document.querySelector('.sn-system-info-text');
+    if (sysInfo && sysInfo.textContent && sysInfo.textContent.trim()) {
+      callback(sysInfo.textContent.trim());
+      return;
+    }
+
+    // Strategy 3: Workspace / Polaris — concourse picker element
+    var concourseText = document.querySelector(
+      '[data-testid="updateset-picker"] span, ' +
+      'sn-polaris-header [aria-label*="update set"] span, ' +
+      '.sn-polaris-updateset-picker span, ' +
+      '[id*="updateset"] .now-dropdown-selected'
+    );
+    if (concourseText && concourseText.textContent && concourseText.textContent.trim()) {
+      callback(concourseText.textContent.trim());
+      return;
+    }
+
+    // Strategy 4: REST API (works everywhere, including workspace)
+    var token = getSecurityToken();
+    if (!token) {
+      // Wait briefly for g_ck bridge, then retry
+      setTimeout(function() {
+        var tok = getSecurityToken();
+        if (tok) fetchUpdateSetViaApi(tok, callback);
+        else callback('');
+      }, 2000);
+      return;
+    }
+    fetchUpdateSetViaApi(token, callback);
+  }
+
+  function fetchUpdateSetViaApi(token, callback) {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', instanceUrl + '/api/now/ui/concoursepicker/updateset', true);
+    xhr.setRequestHeader('Accept', 'application/json');
+    xhr.setRequestHeader('X-UserToken', token);
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200) {
+        try {
+          var data = JSON.parse(xhr.responseText);
+          var name = data.result && data.result.name ? data.result.name : '';
+          if (!name && data.result && data.result.displayValue) name = data.result.displayValue;
+          callback(name || 'Default');
+        } catch(e) { callback(''); }
+      } else {
+        callback('');
+      }
+    };
+    xhr.send();
+  }
+
+  // ─── Technical Names ────────────────────────────────────────────────────────
+
+  function injectTechnicalNames() {
+    if (!isForm && !isWorkspace) return;
+
+    // Combined selector: classic UI + workspace / Polaris / Next Experience
+    var selector = [
+      // Classic UI
+      'label.label-text',
+      '.sn-form-field label',
+      'td.label_left label',
+      // Workspace / Polaris / Next Experience
+      'sn-form-field label',
+      'now-record-form-field label',
+      '[data-field-name] label',
+      '.form-field label',
+      'now-label',
+      'label[for^="sp_formfield_"]',
+    ].join(', ');
+
+    waitForElements(selector, function(labels) {
+      labels.forEach(function(label) {
+        if (label.querySelector('.nowaikit-techname')) return; // Already injected
+
+        var fieldName = '';
+
+        // Strategy 1: Parent with data-field-name (workspace)
+        var fieldParent = label.closest('[data-field-name]');
+        if (fieldParent) {
+          fieldName = fieldParent.getAttribute('data-field-name');
+        }
+
+        // Strategy 2: Classic — extract from input IDs
+        if (!fieldName) {
+          var parent = label.closest('tr, .form-group, .sn-form-field, sn-form-field, now-record-form-field');
+          if (parent) {
+            var input = parent.querySelector('input, select, textarea, now-input, now-select, now-textarea');
+            if (input) {
+              fieldName = input.getAttribute('data-field-name') ||
+                         input.getAttribute('name') ||
+                         (input.getAttribute('id') || '').replace(/^sys_display\./, '').replace(/^ni\./, '').replace(/^sp_formfield_/, '');
+            }
+          }
+        }
+
+        // Strategy 3: label "for" attribute
+        if (!fieldName) {
+          var forAttr = label.getAttribute('for') || '';
+          if (forAttr) {
+            fieldName = forAttr.replace(/^sys_display\./, '').replace(/^ni\./, '').replace(/^sp_formfield_/, '');
+          }
+        }
+
+        // Skip internal/system names
+        if (!fieldName || fieldName.length > 80 || fieldName.includes(' ')) return;
+
+        var badge = document.createElement('span');
+        badge.className = 'nowaikit-techname';
+        badge.textContent = fieldName;
+        badge.title = 'Click to copy field name';
+        badge.addEventListener('click', function(e) {
+          e.preventDefault();
+          e.stopPropagation();
+          navigator.clipboard.writeText(fieldName).then(function() {
+            badge.textContent = 'Copied!';
+            setTimeout(function() { badge.textContent = fieldName; }, 1000);
+          }).catch(function() { /* clipboard denied */ });
+        });
+        label.appendChild(badge);
+      });
+    }, 10000);
+  }
+
+  // ─── Field Copy ─────────────────────────────────────────────────────────────
+
+  function injectFieldCopy() {
+    if (!isForm && !isWorkspace) return;
+
+    // Combined selectors: classic + workspace / Polaris
+    var selector = [
+      '.form-control',
+      '.sn-field-value',
+      'td.vt',
+      // Workspace / Polaris
+      'now-input',
+      'now-textarea',
+      '[data-field-name] .now-line-height-crop',
+      'sn-form-field .value-display',
+      '.sn-form-field-value',
+    ].join(', ');
+
+    waitForElements(selector, function(displayValues) {
+      displayValues.forEach(function(el) {
+        if (el.querySelector('.nowaikit-copy-btn')) return;
+
+        var btn = document.createElement('button');
+        btn.className = 'nowaikit-copy-btn';
+        btn.innerHTML = '&#x2398;';
+        btn.title = 'Copy value';
+        btn.addEventListener('click', function(e) {
+          e.preventDefault();
+          e.stopPropagation();
+          // Try multiple value sources
+          var value = el.value ||
+                     (el.getAttribute && el.getAttribute('value')) ||
+                     (el.textContent ? el.textContent.trim() : '');
+          navigator.clipboard.writeText(value).then(function() {
+            btn.innerHTML = '&#x2713;';
+            setTimeout(function() { btn.innerHTML = '&#x2398;'; }, 1000);
+          }).catch(function() { /* clipboard denied */ });
+        });
+
+        el.style.position = 'relative';
+        el.appendChild(btn);
+      });
+    }, 10000);
+  }
+
+  // ─── 3D. Field Type Tooltips ──────────────────────────────────────────────
+
+  function injectFieldTypeTooltips() {
+    if ((!isForm && !isWorkspace) || !currentTable) return;
+
+    fetchFieldMetadata(currentTable, function(fields) {
+      if (!fields || fields.length === 0) return;
+
+      // Build a lookup by element (column) name
+      const lookup = {};
+      fields.forEach(function(f) {
+        lookup[f.element] = f;
+      });
+
+      // Find all technical name badges and attach tooltip behavior
+      const badges = document.querySelectorAll('.nowaikit-techname');
+      badges.forEach(function(badge) {
+        const fieldName = badge.textContent;
+        if (fieldName === 'Copied!' || !lookup[fieldName]) return;
+
+        const meta = lookup[fieldName];
+
+        badge.classList.add('nowaikit-has-tooltip');
+
+        // Build tooltip content
+        const tooltipData = [];
+        tooltipData.push('Type: ' + (meta.internal_type_display || meta.internal_type || 'unknown'));
+        if (meta.max_length) tooltipData.push('Max Length: ' + meta.max_length);
+        if (meta.reference) tooltipData.push('Reference: ' + meta.reference);
+        if (meta.mandatory === 'true') tooltipData.push('Mandatory: Yes');
+        if (meta.read_only === 'true') tooltipData.push('Read Only: Yes');
+        if (meta.default_value) tooltipData.push('Default: ' + meta.default_value);
+
+        badge.addEventListener('mouseenter', function() {
+          showFieldTooltip(badge, tooltipData);
+        });
+        badge.addEventListener('mouseleave', function() {
+          hideFieldTooltip();
+        });
+      });
+    });
+  }
+
+  /**
+   * Fetch field metadata from sys_dictionary for a given table.
+   * Caches results per table so only one request is made per table per page load.
+   */
+  function fetchFieldMetadata(tableName, callback) {
+    if (fieldMetadataCache[tableName]) {
+      callback(fieldMetadataCache[tableName]);
+      return;
+    }
+
+    const url = instanceUrl + '/api/now/table/sys_dictionary'
+      + '?sysparm_query=name=' + encodeURIComponent(tableName)
+      + '&sysparm_fields=element,internal_type,max_length,reference,mandatory,read_only,default_value,column_label'
+      + '&sysparm_limit=500'
+      + '&sysparm_display_value=all';
+
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.setRequestHeader('Accept', 'application/json');
+    xhr.setRequestHeader('X-UserToken', getSecurityToken());
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200) {
+        try {
+          const data = JSON.parse(xhr.responseText);
+          const results = (data.result || []).map(function(r) {
+            return {
+              element: r.element && r.element.display_value ? r.element.display_value : (r.element || ''),
+              internal_type: r.internal_type && r.internal_type.value ? r.internal_type.value : (r.internal_type || ''),
+              internal_type_display: r.internal_type && r.internal_type.display_value ? r.internal_type.display_value : '',
+              max_length: r.max_length && r.max_length.display_value ? r.max_length.display_value : (r.max_length || ''),
+              reference: r.reference && r.reference.display_value ? r.reference.display_value : (r.reference || ''),
+              mandatory: r.mandatory && r.mandatory.value ? r.mandatory.value : (r.mandatory || ''),
+              read_only: r.read_only && r.read_only.value ? r.read_only.value : (r.read_only || ''),
+              default_value: r.default_value && r.default_value.display_value ? r.default_value.display_value : (r.default_value || ''),
+              column_label: r.column_label && r.column_label.display_value ? r.column_label.display_value : (r.column_label || ''),
+            };
+          }).filter(function(r) { return r.element; });
+
+          fieldMetadataCache[tableName] = results;
+          callback(results);
+        } catch(e) {
+          callback([]);
+        }
+      } else {
+        callback([]);
+      }
+    };
+    xhr.send();
+  }
+
+  /**
+   * Get the ServiceNow g_ck security token for API requests.
+   *
+   * Content scripts run in an isolated JavaScript world — they CANNOT access
+   * the page's window.g_ck directly. We use multiple strategies:
+   *   1. Read from our injected bridge element (most reliable)
+   *   2. Read from SN-Utils bridge element (if installed)
+   *   3. Parse from inline <script> tags in the DOM
+   */
+  function getSecurityToken() {
+    // Method 1: Our injected bridge element (set by injectGckBridge)
+    var bridgeEl = document.getElementById('nowaikit-gck');
+    if (bridgeEl && bridgeEl.value) return bridgeEl.value;
+
+    // Method 2: SN-Utils bridge element (if that extension is installed)
+    var snuEl = document.getElementById('sn_gck');
+    if (snuEl && snuEl.value) return snuEl.value;
+
+    // Method 3: Parse from inline <script> tags (works for classic UI)
+    var scripts = document.querySelectorAll('script');
+    for (var i = 0; i < scripts.length; i++) {
+      var text = scripts[i].textContent || '';
+      var match = text.match(/var\s+g_ck\s*=\s*['"]([^'"]+)['"]/);
+      if (match && match[1]) return match[1];
+    }
+
+    // Method 4: Meta tag (some Next Experience versions)
+    var metaEl = document.querySelector('meta[name="g_ck"], meta[name="_ck"]');
+    if (metaEl && metaEl.getAttribute('content')) return metaEl.getAttribute('content');
+
+    console.warn('[NowAIKit] g_ck token not found — API calls may fail');
+    return '';
+  }
+
+  /**
+   * Inject a micro-script into the PAGE context to extract g_ck.
+   * Content scripts cannot access page JS variables directly, so we inject
+   * a script that reads g_ck and stores it in a hidden DOM element.
+   */
+  function injectGckBridge() {
+    // Don't inject if already present
+    if (document.getElementById('nowaikit-gck')) return;
+
+    var script = document.createElement('script');
+    script.textContent = '(function(){' +
+      'try{' +
+        'var el=document.createElement("input");' +
+        'el.type="hidden";' +
+        'el.id="nowaikit-gck";' +
+        'el.value=(typeof g_ck!=="undefined"&&g_ck)?g_ck:"";' +
+        'document.documentElement.appendChild(el);' +
+        // Also listen for g_ck changes (e.g. after page framework init)
+        'if(!el.value){' +
+          'var _t=setInterval(function(){' +
+            'if(typeof g_ck!=="undefined"&&g_ck){' +
+              'el.value=g_ck;clearInterval(_t);' +
+            '}' +
+          '},2000);' +
+          'setTimeout(function(){clearInterval(_t);},8000);' +
+        '}' +
+      '}catch(e){}' +
+    '})();';
+    (document.head || document.documentElement).appendChild(script);
+    script.remove(); // Clean up — the script already executed
+  }
+
+  /** Active tooltip element */
+  let activeTooltip = null;
+
+  function showFieldTooltip(anchor, lines) {
+    hideFieldTooltip();
+
+    const tooltip = document.createElement('div');
+    tooltip.className = 'nowaikit-field-tooltip';
+    tooltip.innerHTML = lines.map(function(line) {
+      const parts = line.split(': ');
+      return '<div class="nowaikit-tooltip-row">'
+        + '<span class="nowaikit-tooltip-key">' + escapeHtml(parts[0]) + '</span>'
+        + '<span class="nowaikit-tooltip-val">' + escapeHtml(parts.slice(1).join(': ')) + '</span>'
+        + '</div>';
+    }).join('');
+
+    document.body.appendChild(tooltip);
+    activeTooltip = tooltip;
+
+    // Position below the badge
+    const rect = anchor.getBoundingClientRect();
+    tooltip.style.top = (rect.bottom + window.scrollY + 4) + 'px';
+    tooltip.style.left = (rect.left + window.scrollX) + 'px';
+
+    // Ensure tooltip doesn't overflow viewport right edge
+    requestAnimationFrame(function() {
+      if (!activeTooltip) return;
+      const tRect = tooltip.getBoundingClientRect();
+      if (tRect.right > window.innerWidth - 8) {
+        tooltip.style.left = (window.innerWidth - tRect.width - 8) + 'px';
+      }
+    });
+  }
+
+  function hideFieldTooltip() {
+    if (activeTooltip) {
+      activeTooltip.remove();
+      activeTooltip = null;
+    }
+  }
+
+  // ─── Quick Navigation ──────────────────────────────────────────────────────
+
+  function injectQuickNav() {
+    if (document.getElementById('nowaikit-quicknav')) return; // Already injected
+    const nav = document.createElement('div');
+    nav.id = 'nowaikit-quicknav';
+    nav.innerHTML = '\
+      <input type="text" id="nowaikit-quicknav-input"\
+             placeholder="Table, sys_id, or /command..."\
+             autocomplete="off" />\
+    ';
+    nav.style.display = 'none';
+    document.body.appendChild(nav);
+
+    const input = document.getElementById('nowaikit-quicknav-input');
+    input.addEventListener('keydown', function(e) {
+      if (e.key === 'Escape') {
+        nav.style.display = 'none';
+        return;
+      }
+      if (e.key === 'Enter') {
+        const value = input.value.trim();
+        if (value) {
+          navigateTo(value);
+        }
+        nav.style.display = 'none';
+        input.value = '';
+      }
+    });
+
+    input.addEventListener('blur', function() {
+      setTimeout(function() { nav.style.display = 'none'; }, 200);
+    });
+  }
+
+  function navigateTo(input) {
+    let url = '';
+
+    // ─── Slash Commands ─────────────────────────────────────────
+    if (input.startsWith('/')) {
+      const parts = input.substring(1).split(/\s+/);
+      const cmd = parts[0].toLowerCase();
+      const arg = parts.slice(1).join(' ');
+
+      switch (cmd) {
+        case 'docs':
+          url = 'https://docs.servicenow.com/search?q=' + encodeURIComponent(arg || 'home');
+          window.open(url, '_blank');
+          return;
+        case 'api':
+          if (arg) {
+            url = instanceUrl + '/api/now/table/' + encodeURIComponent(arg) + '?sysparm_limit=1';
+            window.open(url, '_blank');
+          } else {
+            url = instanceUrl + '/api/now/doc/table/schema';
+            window.open(url, '_blank');
+          }
+          return;
+        case 'script':
+          if (arg) {
+            url = instanceUrl + '/nav_to.do?uri=sys_script_list.do?sysparm_query=nameLIKE' + encodeURIComponent(arg) + '^ORsys_script_client.nameLIKE' + encodeURIComponent(arg);
+          } else {
+            url = instanceUrl + '/nav_to.do?uri=sys_script_list.do';
+          }
+          window.open(url, '_blank');
+          return;
+        case 'us':
+        case 'updateset':
+          url = instanceUrl + '/nav_to.do?uri=sys_update_set_list.do?sysparm_query=state=in progress';
+          window.open(url, '_blank');
+          return;
+        case 'node':
+          var nodeInfo = detectNode();
+          showToast(nodeInfo ? 'Node: ' + nodeInfo : 'Node info not available');
+          return;
+        case 'env':
+          url = instanceUrl + '/stats.do';
+          window.open(url, '_blank');
+          return;
+        case 'diff':
+          if (arg && /^[a-f0-9]{32}$/.test(arg)) {
+            url = instanceUrl + '/sys_update_xml_list.do?sysparm_query=name=' + arg;
+            window.open(url, '_blank');
+          } else {
+            showToast('Usage: /diff <sys_id>');
+          }
+          return;
+        case 'bg':
+        case 'scripts-bg':
+          url = instanceUrl + '/sys.scripts.do';
+          window.open(url, '_blank');
+          return;
+        case 'log':
+        case 'logs':
+          url = instanceUrl + '/syslog_list.do?sysparm_query=level=2^ORlevel=3^ORDERBYDESCsys_created_on';
+          window.open(url, '_blank');
+          return;
+        case 'tables':
+          url = instanceUrl + '/sys_db_object_list.do';
+          window.open(url, '_blank');
+          return;
+        default:
+          showToast('Unknown command: /' + cmd);
+          return;
+      }
+    }
+
+    // If it looks like a sys_id
+    if (/^[a-f0-9]{32}$/.test(input)) {
+      if (currentTable) {
+        url = instanceUrl + '/' + currentTable + '.do?sys_id=' + input;
+      } else {
+        url = instanceUrl + '/sys_metadata.do?sys_id=' + input;
+      }
+    }
+    // If it looks like table.do format
+    else if (input.includes('.do')) {
+      url = instanceUrl + '/' + input;
+    }
+    // If it looks like a table name
+    else if (/^[a-z_]+$/.test(input)) {
+      url = instanceUrl + '/' + input + '_list.do';
+    }
+    // Otherwise, navigate to it
+    else {
+      url = instanceUrl + '/nav_to.do?uri=' + encodeURIComponent(input);
+    }
+
+    window.open(url, '_blank');
+  }
+
+  // ─── Info Overlay ──────────────────────────────────────────────────────────
+
+  function injectInfoOverlay() {
+    if (!currentTable) return;
+
+    const overlay = document.createElement('div');
+    overlay.id = 'nowaikit-info-overlay';
+
+    let html = '\
+      <div class="nowaikit-info-row">\
+        <span class="nowaikit-info-label">Table</span>\
+        <span class="nowaikit-info-value nowaikit-clickable" data-copy="' + escapeHtml(currentTable) + '">' + escapeHtml(currentTable) + '</span>\
+      </div>';
+
+    if (currentSysId) {
+      html += '\
+      <div class="nowaikit-info-row">\
+        <span class="nowaikit-info-label">sys_id</span>\
+        <span class="nowaikit-info-value nowaikit-clickable" data-copy="' + currentSysId + '">' + currentSysId.substring(0, 8) + '...</span>\
+      </div>';
+    }
+
+    html += '\
+      <div class="nowaikit-info-row">\
+        <span class="nowaikit-info-label">Instance</span>\
+        <span class="nowaikit-info-value">' + window.location.hostname.split('.')[0] + '</span>\
+      </div>';
+
+    // 3C. Node detection — add node info row (clickable to open switcher)
+    const nodeInfo = detectNode();
+    html += '\
+      <div class="nowaikit-info-row">\
+        <span class="nowaikit-info-label">Node</span>\
+        <span class="nowaikit-info-value nowaikit-node-value nowaikit-node-switch-trigger" title="Click to switch node">' + escapeHtml(nodeInfo || 'unknown') + '</span>\
+      </div>';
+
+    overlay.innerHTML = html;
+
+    // Make values clickable to copy
+    overlay.querySelectorAll('.nowaikit-clickable').forEach(function(el) {
+      el.addEventListener('click', function() {
+        navigator.clipboard.writeText(el.dataset.copy).then(function() {
+          el.textContent = 'Copied!';
+          setTimeout(function() {
+            el.textContent = el.dataset.copy.length > 20
+              ? el.dataset.copy.substring(0, 8) + '...'
+              : el.dataset.copy;
+          }, 1000);
+        }).catch(function() { /* clipboard denied */ });
+      });
+    });
+
+    // Make node value clickable to open node switcher
+    var nodeSwitch = overlay.querySelector('.nowaikit-node-switch-trigger');
+    if (nodeSwitch) {
+      nodeSwitch.style.cursor = 'pointer';
+      nodeSwitch.addEventListener('click', function(e) {
+        e.stopPropagation();
+        openNodeSwitcher();
+      });
+    }
+
+    document.body.appendChild(overlay);
+  }
+
+  // ─── 3C. Enhanced Node Switcher ───────────────────────────────────────────
+
+  /**
+   * Detects the ServiceNow application node serving this page.
+   * Uses multiple sources:
+   *   1. glide_node cookie
+   *   2. Performance API Server-Timing header
+   *   3. X-ServiceNow-Node response header (via performance entries)
+   */
+  function detectNode() {
+    let node = '';
+
+    // Method 1: glide_user_route cookie (correct ServiceNow cookie)
+    // Value format: "glide.{nodeId}" — strip the "glide." prefix
+    node = getCookieValue('glide_user_route');
+    if (node) {
+      return node.indexOf('glide.') === 0 ? node.substring(6) : node;
+    }
+
+    // Method 2: glide_node cookie (legacy)
+    node = getCookieValue('glide_node');
+    if (node) return node;
+
+    // Method 3: glide.node cookie (alternate naming)
+    node = getCookieValue('glide.node');
+    if (node) return node;
+
+    // Method 4: Performance API — Server-Timing header
+    if (window.performance && typeof window.performance.getEntriesByType === 'function') {
+      try {
+        const navEntries = window.performance.getEntriesByType('navigation');
+        for (let i = 0; i < navEntries.length; i++) {
+          const entry = navEntries[i];
+          if (entry.serverTiming && entry.serverTiming.length > 0) {
+            for (let j = 0; j < entry.serverTiming.length; j++) {
+              const st = entry.serverTiming[j];
+              if (st.name === 'glide_node' || st.name === 'node') {
+                return st.description || st.name;
+              }
+            }
+          }
+        }
+      } catch(e) { /* ignore */ }
+    }
+
+    // Method 4: Performance API — resource entries with server timing
+    if (window.performance && typeof window.performance.getEntriesByType === 'function') {
+      try {
+        const resources = window.performance.getEntriesByType('resource');
+        for (let i = resources.length - 1; i >= 0 && i >= resources.length - 10; i--) {
+          const entry = resources[i];
+          if (entry.serverTiming && entry.serverTiming.length > 0) {
+            for (let j = 0; j < entry.serverTiming.length; j++) {
+              var st = entry.serverTiming[j];
+              if (st.name === 'glide_node' || st.name === 'node') {
+                return st.description || st.name;
+              }
+            }
+          }
+        }
+      } catch(e) { /* ignore */ }
+    }
+
+    // Method 5: Check for node info in page (sometimes exposed in system diagnostics)
+    var nodeEl = document.querySelector('[data-node], .instance-node');
+    if (nodeEl) {
+      return nodeEl.getAttribute('data-node') || nodeEl.textContent.trim();
+    }
+
+    return '';
+  }
+
+  function getCookieValue(name) {
+    const cookies = document.cookie.split(';');
+    for (let i = 0; i < cookies.length; i++) {
+      const c = cookies[i].trim();
+      if (c.indexOf(name + '=') === 0) {
+        return decodeURIComponent(c.substring(name.length + 1));
+      }
+    }
+    return '';
+  }
+
+  // ─── Node Switcher ──────────────────────────────────────────────────────
+
+  /**
+   * Fetches available application nodes from sys_cluster_state.
+   * Uses three strategies: sys_cluster_state API → stats.do JSON → xmlstats.do XML
+   * @param {function} callback - Called with array of node objects
+   */
+  function fetchAvailableNodes(callback) {
+    // Delay slightly to allow g_ck bridge to initialize
+    var token = getSecurityToken();
+    if (!token) {
+      console.warn('[NowAIKit] No security token yet, retrying in 1s...');
+      setTimeout(function() {
+        var retryToken = getSecurityToken();
+        if (!retryToken) {
+          console.warn('[NowAIKit] No security token available for node discovery');
+          callback([]);
+          return;
+        }
+        doFetchNodes(retryToken, callback);
+      }, 1000);
+      return;
+    }
+    doFetchNodes(token, callback);
+  }
+
+  function doFetchNodes(token, callback) {
+    // Strategy 1: Query sys_cluster_state REST API (same as SN-Utils)
+    var url = instanceUrl + '/api/now/table/sys_cluster_state'
+      + '?sysparm_query=ORDERBYsystem_id'
+      + '&sysparm_fields=system_id,node_id,status,node_type'
+      + '&sysparm_display_value=true'
+      + '&sysparm_exclude_reference_link=true'
+      + '&sysparm_limit=50';
+
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.setRequestHeader('Accept', 'application/json');
+    xhr.setRequestHeader('X-UserToken', token);
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+
+      console.info('[NowAIKit] sys_cluster_state response: HTTP ' + xhr.status);
+
+      if (xhr.status === 200) {
+        try {
+          var data = JSON.parse(xhr.responseText);
+          var results = data.result || [];
+          if (results.length > 0) {
+            var nodes = results.map(function(r) {
+              return {
+                systemId: r.system_id || '',
+                nodeId: r.node_id || r.system_id || '',
+                status: r.status || 'online',
+                nodeType: r.node_type || '',
+                lastTransaction: '',
+                discoveredVia: 'sys_cluster_state API',
+              };
+            });
+            console.info('[NowAIKit] Discovered ' + nodes.length + ' node(s) via sys_cluster_state API');
+            callback(nodes);
+            return;
+          } else {
+            console.warn('[NowAIKit] sys_cluster_state returned 0 results');
+          }
+        } catch(e) {
+          console.warn('[NowAIKit] sys_cluster_state parse error:', e.message || e);
+        }
+      } else if (xhr.status === 401 || xhr.status === 403) {
+        console.warn('[NowAIKit] sys_cluster_state: Access denied (HTTP ' + xhr.status + '). Are you an admin? g_ck token length: ' + (token ? token.length : 0));
+      } else if (xhr.status !== 0) {
+        console.warn('[NowAIKit] sys_cluster_state query failed: HTTP ' + xhr.status);
+      }
+
+      // Strategy 2: Fallback — parse stats.do HTML
+      fetchNodesFromStatsDo(callback);
+    };
+    xhr.send();
+  }
+
+  /**
+   * Strategy 2: Fetch node info from stats.do HTML page.
+   * stats.do returns an HTML page with "Node ID: xxx" and "IP address: x.x.x.x".
+   * This only shows the CURRENT node — not all cluster nodes.
+   * Used as fallback info when sys_cluster_state fails.
+   * @param {function} callback - Called with array of node objects
+   */
+  function fetchNodesFromStatsDo(callback) {
+    var url = instanceUrl + '/stats.do';
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200 && xhr.responseText) {
+        var html = xhr.responseText;
+        var nodes = [];
+
+        // Parse Node ID from stats.do HTML (format: "Node ID: xxx<br/>")
+        var nodeIdMatch = html.match(/Node ID:\s*([\s\S]*?)\s*<br/i);
+        var nodeNameMatch = html.match(/Connected to cluster node:\s*([\s\S]*?)\s*<br/i);
+
+        if (nodeIdMatch && nodeIdMatch[1]) {
+          var nodeId = nodeIdMatch[1].replace(/<[^>]*>/g, '').trim();
+          var nodeName = nodeNameMatch ? nodeNameMatch[1].replace(/<[^>]*>/g, '').trim() : nodeId;
+          nodes.push({
+            systemId: nodeName || nodeId,
+            nodeId: nodeId,
+            status: 'online',
+            nodeType: '',
+            lastTransaction: '',
+            discoveredVia: 'stats.do (current node only)',
+          });
+          console.info('[NowAIKit] Found current node via stats.do: ' + nodeId);
+        }
+
+        if (nodes.length > 0) {
+          callback(nodes);
+          return;
+        }
+      }
+      if (xhr.status !== 0 && xhr.status !== 200) {
+        console.warn('[NowAIKit] stats.do query failed: HTTP ' + xhr.status);
+      }
+      // Strategy 3: Fallback — try xmlstats.do
+      fetchNodesFromXmlStats(callback);
+    };
+    xhr.send();
+  }
+
+  /**
+   * Strategy 3: Fallback node discovery using xmlstats.do.
+   * Parses the XML response to extract node IDs.
+   */
+  function fetchNodesFromXmlStats(callback) {
+    var url = instanceUrl + '/xmlstats.do';
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200 && xhr.responseText) {
+        try {
+          var nodes = parseXmlStatsNodes(xhr.responseText);
+          if (nodes.length > 0) {
+            console.info('[NowAIKit] Discovered ' + nodes.length + ' node(s) via xmlstats.do');
+            callback(nodes);
+            return;
+          }
+        } catch(e) {
+          console.warn('[NowAIKit] xmlstats.do parse error:', e.message || e);
+        }
+      } else if (xhr.status !== 0) {
+        console.warn('[NowAIKit] xmlstats.do query failed: HTTP ' + xhr.status);
+      }
+      // Strategy 4: Final fallback — build list from current node only
+      // User can still manually enter node IDs
+      var currentNode = detectNode();
+      if (currentNode) {
+        console.info('[NowAIKit] Using current node as fallback: ' + currentNode);
+        callback([{
+          systemId: currentNode,
+          nodeId: currentNode,
+          status: 'online',
+          nodeType: '',
+          lastTransaction: '',
+          discoveredVia: 'current node detection',
+        }]);
+      } else {
+        console.warn('[NowAIKit] No nodes discovered via any strategy');
+        callback([]);
+      }
+    };
+    xhr.send();
+  }
+
+  /**
+   * Parse xmlstats.do response to extract node information.
+   * xmlstats.do returns XML with various node/servlet elements depending on version.
+   */
+  function parseXmlStatsNodes(xmlText) {
+    var nodes = [];
+    var seen = {};
+    try {
+      var parser = new DOMParser();
+      var doc = parser.parseFromString(xmlText, 'text/xml');
+
+      // Check for parse errors
+      var parseError = doc.querySelector('parsererror');
+      if (parseError) {
+        console.warn('[NowAIKit] xmlstats.do returned invalid XML, falling back to regex');
+      } else {
+        // Look for elements with node info — expanded selectors for different SN versions
+        var selectors = 'node, servlet_info, stats, cluster_node, node_stats, servlet, system_node, cluster_state';
+        var nodeEls = doc.querySelectorAll(selectors);
+        for (var i = 0; i < nodeEls.length; i++) {
+          var el = nodeEls[i];
+          var sysId = el.getAttribute('system_id')
+            || el.getAttribute('node_id')
+            || el.getAttribute('name')
+            || el.getAttribute('id')
+            || el.getAttribute('node_name')
+            || '';
+
+          // Also check child elements for system_id
+          if (!sysId) {
+            var sysIdEl = el.querySelector('system_id, node_id');
+            if (sysIdEl) sysId = sysIdEl.textContent.trim();
+          }
+
+          if (sysId && !seen[sysId]) {
+            seen[sysId] = true;
+            nodes.push({
+              systemId: sysId,
+              nodeId: sysId,
+              status: el.getAttribute('status') || 'online',
+              nodeType: el.getAttribute('node_type') || el.getAttribute('type') || '',
+              lastTransaction: '',
+              discoveredVia: 'xmlstats.do',
+            });
+          }
+        }
+
+        // Also scan all elements for system_id attributes (catch-all)
+        if (nodes.length === 0) {
+          var allEls = doc.querySelectorAll('[system_id], [node_id]');
+          for (var k = 0; k < allEls.length; k++) {
+            var attrId = allEls[k].getAttribute('system_id') || allEls[k].getAttribute('node_id') || '';
+            if (attrId && !seen[attrId]) {
+              seen[attrId] = true;
+              nodes.push({
+                systemId: attrId,
+                nodeId: attrId,
+                status: 'online',
+                nodeType: '',
+                lastTransaction: '',
+                discoveredVia: 'xmlstats.do',
+              });
+            }
+          }
+        }
+      }
+
+      // Fallback: regex extraction from raw text
+      if (nodes.length === 0) {
+        var patterns = [
+          /system_id[>":\s]+([a-zA-Z0-9._:-]+)/g,
+          /node_id[>":\s]+([a-zA-Z0-9._:-]+)/g,
+          /node_name[>":\s]+([a-zA-Z0-9._:-]+)/g,
+        ];
+        for (var p = 0; p < patterns.length; p++) {
+          var match = xmlText.match(patterns[p]);
+          if (match) {
+            for (var j = 0; j < match.length; j++) {
+              var idMatch = match[j].match(/[>":\s]+([a-zA-Z0-9._:-]+)/);
+              if (idMatch && idMatch[1] && !seen[idMatch[1]]) {
+                seen[idMatch[1]] = true;
+                nodes.push({
+                  systemId: idMatch[1],
+                  nodeId: idMatch[1],
+                  status: 'online',
+                  nodeType: '',
+                  lastTransaction: '',
+                  discoveredVia: 'xmlstats.do',
+                });
+              }
+            }
+          }
+          if (nodes.length > 0) break;
+        }
+      }
+    } catch(e) {
+      console.warn('[NowAIKit] xmlstats.do parse exception:', e.message || e);
+    }
+    return nodes;
+  }
+
+  /**
+   * Switches to a specific application node by setting glide_user_route cookie
+   * and optionally the F5 BIG-IP load balancer cookie.
+   *
+   * Handles three load-balancer scenarios:
+   *   1. On-prem / no LB: set glide_user_route only
+   *   2. Classic F5 BIG-IP: set BIGipServerpool (encoded IP.port) + glide_user_route
+   *   3. ADCv2: set BIGipServerpool (md5 of ip:port) + glide_user_route
+   *
+   * All cookies set via chrome.cookies API (httpOnly, secure).
+   *
+   * @param {string} nodeId - The target node_id
+   */
+  function switchToNode(nodeId) {
+    var origin = window.location.origin;
+
+    // Get current IP info from stats.do and check for F5 load balancer
+    fetchStatsDoInfo(function(statsInfo) {
+      chrome.runtime.sendMessage({ action: 'getAllCookies', url: origin }, function(resp) {
+        if (chrome.runtime.lastError || !resp || !resp.cookies) {
+          applyRouteAndReload(origin, nodeId);
+          return;
+        }
+
+        // Find BIGipServerpool cookie — indicates F5 LB
+        var lbCookie = null;
+        for (var i = 0; i < resp.cookies.length; i++) {
+          if (/^BIGipServer[\w\d]+$/.test(resp.cookies[i].name)) {
+            lbCookie = resp.cookies[i];
+            break;
+          }
+        }
+
+        if (!lbCookie) {
+          // No F5 — on-prem or direct. Route cookie is sufficient.
+          console.info('[NowAIKit] No F5 LB cookie found, setting route only');
+          applyRouteAndReload(origin, nodeId);
+          return;
+        }
+
+        console.info('[NowAIKit] F5 LB detected: ' + lbCookie.name);
+
+        if (!statsInfo || !statsInfo.ipParts || statsInfo.ipParts.length !== 4) {
+          console.warn('[NowAIKit] Could not parse IP from stats.do, setting route only');
+          applyRouteAndReload(origin, nodeId);
+          return;
+        }
+
+        // Fetch servlet port from sys_cluster_node_stats for the target node
+        fetchServletPort(nodeId, function(port) {
+          if (!port) {
+            console.warn('[NowAIKit] Could not get servlet port, setting route only');
+            applyRouteAndReload(origin, nodeId);
+            return;
+          }
+
+          var lbValue;
+          var ipArr = statsInfo.ipParts;
+
+          if (lbCookie.value && !lbCookie.value.endsWith('.0000')) {
+            // ADCv2 scheme — cookie value is md5(ip:port)
+            var fullIp = ipArr.join('.');
+            lbValue = nowaikitMd5(fullIp + ':' + port);
+            console.info('[NowAIKit] ADCv2 encoding: md5(' + fullIp + ':' + port + ')');
+          } else {
+            // Classic F5 scheme — little-endian IP + swapped port
+            var encodedIP = 0;
+            for (var i = 0; i < 4; i++) {
+              encodedIP += parseInt(ipArr[i], 10) * Math.pow(256, i);
+            }
+            var encodedPort = Math.floor(port / 256) + (port % 256) * 256;
+            lbValue = encodedIP + '.' + encodedPort + '.0000';
+            console.info('[NowAIKit] Classic F5 encoding: ' + lbValue);
+          }
+
+          // Set LB cookie first, then route cookie, then reload
+          chrome.runtime.sendMessage({
+            action: 'setCookie', url: origin, name: lbCookie.name,
+            value: lbValue, path: '/', httpOnly: true, secure: true,
+          }, function() {
+            applyRouteAndReload(origin, nodeId);
+          });
+        });
+      });
+    });
+  }
+
+  /** Set glide_user_route and reload page */
+  function applyRouteAndReload(origin, nodeId) {
+    chrome.runtime.sendMessage({
+      action: 'setCookie', url: origin, name: 'glide_user_route',
+      value: 'glide.' + nodeId, path: '/', httpOnly: true, secure: true,
+    }, function() {
+      if (chrome.runtime.lastError) {
+        console.warn('[NowAIKit] setCookie error:', chrome.runtime.lastError.message);
+      }
+      window.location.reload();
+    });
+  }
+
+  /** MD5 hash for ADCv2 F5 cookie encoding (Joseph Myers implementation) */
+  function nowaikitMd5(str) {
+    function md5cycle(x, k) {
+      var a = x[0], b = x[1], c = x[2], d = x[3];
+      a=ff(a,b,c,d,k[0],7,-680876936);d=ff(d,a,b,c,k[1],12,-389564586);c=ff(c,d,a,b,k[2],17,606105819);b=ff(b,c,d,a,k[3],22,-1044525330);
+      a=ff(a,b,c,d,k[4],7,-176418897);d=ff(d,a,b,c,k[5],12,1200080426);c=ff(c,d,a,b,k[6],17,-1473231341);b=ff(b,c,d,a,k[7],22,-45705983);
+      a=ff(a,b,c,d,k[8],7,1770035416);d=ff(d,a,b,c,k[9],12,-1958414417);c=ff(c,d,a,b,k[10],17,-42063);b=ff(b,c,d,a,k[11],22,-1990404162);
+      a=ff(a,b,c,d,k[12],7,1804603682);d=ff(d,a,b,c,k[13],12,-40341101);c=ff(c,d,a,b,k[14],17,-1502002290);b=ff(b,c,d,a,k[15],22,1236535329);
+      a=gg(a,b,c,d,k[1],5,-165796510);d=gg(d,a,b,c,k[6],9,-1069501632);c=gg(c,d,a,b,k[11],14,643717713);b=gg(b,c,d,a,k[0],20,-373897302);
+      a=gg(a,b,c,d,k[5],5,-701558691);d=gg(d,a,b,c,k[10],9,38016083);c=gg(c,d,a,b,k[15],14,-660478335);b=gg(b,c,d,a,k[4],20,-405537848);
+      a=gg(a,b,c,d,k[9],5,568446438);d=gg(d,a,b,c,k[14],9,-1019803690);c=gg(c,d,a,b,k[3],14,-187363961);b=gg(b,c,d,a,k[8],20,1163531501);
+      a=gg(a,b,c,d,k[13],5,-1444681467);d=gg(d,a,b,c,k[2],9,-51403784);c=gg(c,d,a,b,k[7],14,1735328473);b=gg(b,c,d,a,k[12],20,-1926607734);
+      a=hh(a,b,c,d,k[5],4,-378558);d=hh(d,a,b,c,k[8],11,-2022574463);c=hh(c,d,a,b,k[11],16,1839030562);b=hh(b,c,d,a,k[14],23,-35309556);
+      a=hh(a,b,c,d,k[1],4,-1530992060);d=hh(d,a,b,c,k[4],11,1272893353);c=hh(c,d,a,b,k[7],16,-155497632);b=hh(b,c,d,a,k[10],23,-1094730640);
+      a=hh(a,b,c,d,k[13],4,681279174);d=hh(d,a,b,c,k[0],11,-358537222);c=hh(c,d,a,b,k[3],16,-722521979);b=hh(b,c,d,a,k[6],23,76029189);
+      a=hh(a,b,c,d,k[9],4,-640364487);d=hh(d,a,b,c,k[12],11,-421815835);c=hh(c,d,a,b,k[15],16,530742520);b=hh(b,c,d,a,k[2],23,-995338651);
+      a=ii(a,b,c,d,k[0],6,-198630844);d=ii(d,a,b,c,k[7],10,1126891415);c=ii(c,d,a,b,k[14],15,-1416354905);b=ii(b,c,d,a,k[5],21,-57434055);
+      a=ii(a,b,c,d,k[12],6,1700485571);d=ii(d,a,b,c,k[3],10,-1894986606);c=ii(c,d,a,b,k[10],15,-1051523);b=ii(b,c,d,a,k[1],21,-2054922799);
+      a=ii(a,b,c,d,k[8],6,1873313359);d=ii(d,a,b,c,k[15],10,-30611744);c=ii(c,d,a,b,k[6],15,-1560198380);b=ii(b,c,d,a,k[13],21,1309151649);
+      a=ii(a,b,c,d,k[4],6,-145523070);d=ii(d,a,b,c,k[11],10,-1120210379);c=ii(c,d,a,b,k[2],15,718787259);b=ii(b,c,d,a,k[9],21,-343485551);
+      x[0]=ad(a,x[0]);x[1]=ad(b,x[1]);x[2]=ad(c,x[2]);x[3]=ad(d,x[3]);
+    }
+    function cmn(q,a,b,x,s,t){a=ad(ad(a,q),ad(x,t));return ad((a<<s)|(a>>>(32-s)),b);}
+    function ff(a,b,c,d,x,s,t){return cmn((b&c)|((~b)&d),a,b,x,s,t);}
+    function gg(a,b,c,d,x,s,t){return cmn((b&d)|(c&(~d)),a,b,x,s,t);}
+    function hh(a,b,c,d,x,s,t){return cmn(b^c^d,a,b,x,s,t);}
+    function ii(a,b,c,d,x,s,t){return cmn(c^(b|(~d)),a,b,x,s,t);}
+    function ad(a,b){return(a+b)&0xFFFFFFFF;}
+    var hex='0123456789abcdef'.split('');
+    function rh(n){var s='';for(var j=0;j<4;j++)s+=hex[(n>>(j*8+4))&0xF]+hex[(n>>(j*8))&0xF];return s;}
+    var n=((str.length+8)>>>6<<4)+16,bl=new Array(n);
+    for(var i=0;i<n;i++)bl[i]=0;
+    for(var i=0;i<str.length;i++)bl[i>>2]|=str.charCodeAt(i)<<((i%4)<<3);
+    bl[str.length>>2]|=0x80<<((str.length%4)<<3);bl[n-2]=str.length*8;
+    var st=[1732584193,-271733879,-1732584194,271733878];
+    for(var i=0;i<bl.length;i+=16)md5cycle(st,bl.slice(i,i+16));
+    return rh(st[0])+rh(st[1])+rh(st[2])+rh(st[3]);
+  }
+
+  /**
+   * Fetch the servlet port for a target node from sys_cluster_node_stats.
+   * The stats field contains XML with servlet.port inside.
+   *
+   * @param {string} nodeId - The target node ID
+   * @param {function} callback - Called with port number or null
+   */
+  function fetchServletPort(nodeId, callback) {
+    var token = getSecurityToken();
+    if (!token) { callback(null); return; }
+
+    var url = instanceUrl + '/api/now/table/sys_cluster_node_stats'
+      + '?sysparm_query=node_id=' + encodeURIComponent(nodeId)
+      + '&sysparm_fields=stats'
+      + '&sysparm_limit=1';
+
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.setRequestHeader('Accept', 'application/json');
+    xhr.setRequestHeader('X-UserToken', token);
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200) {
+        try {
+          var data = JSON.parse(xhr.responseText);
+          var statsXml = (data.result || [])[0]?.stats;
+          if (statsXml) {
+            // Parse XML to find servlet.port element
+            var parser = new DOMParser();
+            var doc = parser.parseFromString(statsXml, 'text/xml');
+            var portEl = doc.querySelector('servlet\\.port');
+            if (portEl) {
+              var port = parseInt(portEl.textContent, 10);
+              if (port > 0) {
+                callback(port);
+                return;
+              }
+            }
+          }
+        } catch(e) {
+          console.warn('[NowAIKit] sys_cluster_node_stats parse error:', e.message);
+        }
+      }
+      callback(null);
+    };
+    xhr.send();
+  }
+
+  /**
+   * Fetch IP address and node info from stats.do HTML page.
+   * SN returns: "IP address: x.x.x.x<br/>" and "Node ID: xxx<br/>"
+   *
+   * @param {function} callback - Called with { ipParts: string[], nodeId: string } or null
+   */
+  function fetchStatsDoInfo(callback) {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', instanceUrl + '/stats.do', true);
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 200 && xhr.responseText) {
+        var html = xhr.responseText.replace(/<br\s*\/?\s*>/gi, '<br/>');
+        // Parse IP address: "IP address: 10.0.1.100<br/>"
+        var ipMatch = html.match(/IP address:\s*([\d.]+)\s*<br\/>/i);
+        var nodeIdMatch = html.match(/Node ID:\s*([\s\S]*?)\s*<br\/>/i);
+
+        if (ipMatch && ipMatch[1]) {
+          callback({
+            ipParts: ipMatch[1].split('.'),
+            nodeId: nodeIdMatch ? nodeIdMatch[1].replace(/<[^>]*>/g, '').trim() : '',
+          });
+          return;
+        }
+      }
+      callback(null);
+    };
+    xhr.send();
+  }
+
+  /**
+   * Opens the node switcher modal.
+   */
+  /** Extract the short display name from a full node/system ID.
+   *  e.g. "app1234abcd5678:us-virginia-linux-2" → "us-virginia-linux-2"
+   */
+  function nodeDisplayName(fullId) {
+    if (!fullId) return 'unknown';
+    var idx = fullId.lastIndexOf(':');
+    if (idx !== -1 && idx < fullId.length - 1) return fullId.substring(idx + 1);
+    // Sometimes the name is after the first dot (FQDN style)
+    var dotIdx = fullId.indexOf('.');
+    if (dotIdx > 0) return fullId.substring(0, dotIdx);
+    return fullId;
+  }
+
+  function isCurrentNodeMatch(nodeObj, currentNode) {
+    if (!currentNode) return false;
+    var sId = nodeObj.systemId || '';
+    var nId = nodeObj.nodeId || '';
+    return sId === currentNode || nId === currentNode
+      || (sId && currentNode.indexOf(sId) !== -1)
+      || (nId && currentNode.indexOf(nId) !== -1)
+      || (sId && sId.indexOf(currentNode) !== -1);
+  }
+
+  function openNodeSwitcher() {
+    var existing = document.getElementById('nowaikit-node-switcher');
+    if (existing) { existing.remove(); return; }
+
+    var currentNode = detectNode();
+    var selectedNodeId = null;
+
+    var modal = document.createElement('div');
+    modal.id = 'nowaikit-node-switcher';
+    modal.className = 'nowaikit-node-switcher';
+    modal.innerHTML = '\
+      <div class="nowaikit-node-switcher-panel">\
+        <div class="nowaikit-node-switcher-header">\
+          <span>Node Switcher</span>\
+          <button class="nowaikit-node-switcher-close" title="Close">&times;</button>\
+        </div>\
+        <div class="nowaikit-node-switcher-body">\
+          <div class="nowaikit-node-switcher-loading">\
+            <div class="nowaikit-node-spinner"></div>\
+            Discovering nodes\u2026\
+          </div>\
+        </div>\
+        <div class="nowaikit-node-switcher-footer">\
+          <button class="nowaikit-node-switch-btn" disabled>Select a node</button>\
+          <div class="nowaikit-node-footer-hint">Switching nodes may end your current session</div>\
+        </div>\
+      </div>';
+
+    document.body.appendChild(modal);
+
+    var switchBtn = modal.querySelector('.nowaikit-node-switch-btn');
+
+    // Close handlers
+    modal.querySelector('.nowaikit-node-switcher-close').addEventListener('click', function() {
+      modal.remove();
+    });
+    modal.addEventListener('click', function(e) {
+      if (e.target === modal) modal.remove();
+    });
+    function onEsc(e) {
+      if (e.key === 'Escape') { modal.remove(); document.removeEventListener('keydown', onEsc); }
+    }
+    document.addEventListener('keydown', onEsc);
+
+    // Switch button handler
+    switchBtn.addEventListener('click', function() {
+      if (!selectedNodeId) return;
+      switchBtn.disabled = true;
+      switchBtn.textContent = 'Switching\u2026';
+      switchBtn.classList.add('nowaikit-node-switch-btn-loading');
+      switchToNode(selectedNodeId);
+    });
+
+    // Fetch and render nodes
+    fetchAvailableNodes(function(nodes) {
+      var body = modal.querySelector('.nowaikit-node-switcher-body');
+      if (!body) return;
+
+      // Sort: current node first, then alphabetically by display name
+      nodes.sort(function(a, b) {
+        var aCur = isCurrentNodeMatch(a, currentNode);
+        var bCur = isCurrentNodeMatch(b, currentNode);
+        if (aCur && !bCur) return -1;
+        if (!aCur && bCur) return 1;
+        var aName = nodeDisplayName(a.systemId || a.nodeId);
+        var bName = nodeDisplayName(b.systemId || b.nodeId);
+        return aName.localeCompare(bName);
+      });
+
+      if (nodes.length === 0) {
+        body.innerHTML = '<div class="nowaikit-node-switcher-empty">'
+          + 'No nodes discovered. This may be a single-node instance.'
+          + '</div>';
+        switchBtn.style.display = 'none';
+        return;
+      }
+
+      var html = '';
+      for (var i = 0; i < nodes.length; i++) {
+        var n = nodes[i];
+        var fullId = n.systemId || n.nodeId;
+        var displayName = nodeDisplayName(fullId);
+        var isCurrent = isCurrentNodeMatch(n, currentNode);
+        var nodeType = n.nodeType || '';
+
+        html += '<div class="nowaikit-node-item' + (isCurrent ? ' nowaikit-node-current' : '') + '"'
+          + ' data-node-id="' + escapeHtml(fullId) + '">'
+          + '<div class="nowaikit-node-radio"><div class="nowaikit-node-radio-dot"></div></div>'
+          + '<div class="nowaikit-node-details">'
+          + '<div class="nowaikit-node-name">' + escapeHtml(displayName) + '</div>'
+          + '<div class="nowaikit-node-full-id">' + escapeHtml(fullId)
+          + (nodeType ? ' \u00b7 ' + escapeHtml(nodeType) : '') + '</div>'
+          + '</div>'
+          + (isCurrent
+            ? '<span class="nowaikit-node-badge-active">Active</span>'
+            : '<span class="nowaikit-node-badge-available">Available</span>')
+          + '</div>';
+      }
+
+      body.innerHTML = html;
+
+      // Selection handler
+      var allItems = body.querySelectorAll('.nowaikit-node-item');
+      allItems.forEach(function(el) {
+        el.addEventListener('click', function() {
+          var nodeId = el.getAttribute('data-node-id');
+          var isCur = el.classList.contains('nowaikit-node-current');
+
+          // Deselect all
+          allItems.forEach(function(item) { item.classList.remove('nowaikit-node-selected'); });
+
+          if (isCur) {
+            // Clicking the active node deselects
+            selectedNodeId = null;
+            switchBtn.disabled = true;
+            switchBtn.textContent = 'Select a node';
+            return;
+          }
+
+          // Select this node
+          el.classList.add('nowaikit-node-selected');
+          selectedNodeId = nodeId;
+          switchBtn.disabled = false;
+          switchBtn.textContent = 'Switch to ' + nodeDisplayName(nodeId);
+        });
+      });
+    });
+  }
+
+  /**
+   * Format a ServiceNow timestamp to a short relative/absolute string.
+   */
+  function formatTimestamp(ts) {
+    try {
+      var d = new Date(ts);
+      var now = new Date();
+      var diff = Math.floor((now - d) / 1000);
+      if (diff < 60) return diff + 's ago';
+      if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
+      if (diff < 86400) return Math.floor(diff / 3600) + 'h ago';
+      return d.toLocaleDateString();
+    } catch(e) {
+      return ts;
+    }
+  }
+
+  // ─── 3B. Script Syntax Highlighting ───────────────────────────────────────
+
+  /**
+   * Lightweight syntax highlighter for ServiceNow script fields.
+   * Uses an overlay technique — creates a positioned overlay with highlighted
+   * tokens on top of the script textarea, without interfering with native editing.
+   */
+
+  const SN_API_KEYWORDS = [
+    'GlideRecord', 'g_form', 'gs', 'current', 'previous',
+    'GlideAjax', 'GlideAggregate', 'GlideDateTime',
+    'GlideSystem', 'GlideElement', 'GlideSysAttachment',
+    'GlideFilter', 'GlideSession', 'GlideUser',
+    'g_list', 'g_user', 'g_navigation', 'g_scratchpad',
+  ];
+
+  const JS_KEYWORDS = [
+    'var', 'let', 'const', 'function', 'return', 'if', 'else',
+    'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'try', 'catch', 'finally', 'throw', 'new', 'delete', 'typeof',
+    'instanceof', 'in', 'of', 'this', 'class', 'extends', 'super',
+    'import', 'export', 'default', 'true', 'false', 'null', 'undefined',
+    'void', 'with', 'yield', 'async', 'await',
+  ];
+
+  function highlightSyntax(code) {
+    // Tokenize with a simple regex-based approach
+    // Order matters: comments and strings first, then keywords, then numbers
+    const tokens = [];
+    let remaining = code;
+    let pos = 0;
+
+    while (remaining.length > 0) {
+      let matched = false;
+
+      // Single-line comment
+      var m = remaining.match(/^(\/\/[^\n]*)/);
+      if (m) {
+        tokens.push({ type: 'comment', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Multi-line comment
+      m = remaining.match(/^(\/\*[\s\S]*?\*\/)/);
+      if (m) {
+        tokens.push({ type: 'comment', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Double-quoted string
+      m = remaining.match(/^("(?:[^"\\]|\\.)*")/);
+      if (m) {
+        tokens.push({ type: 'string', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Single-quoted string
+      m = remaining.match(/^('(?:[^'\\]|\\.)*')/);
+      if (m) {
+        tokens.push({ type: 'string', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Template literal (backtick)
+      m = remaining.match(/^(`(?:[^`\\]|\\.)*`)/);
+      if (m) {
+        tokens.push({ type: 'string', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Number
+      m = remaining.match(/^(\b\d+\.?\d*(?:[eE][+-]?\d+)?\b)/);
+      if (m) {
+        tokens.push({ type: 'number', text: m[1] });
+        remaining = remaining.substring(m[1].length);
+        matched = true;
+        continue;
+      }
+
+      // Word (identifier or keyword)
+      m = remaining.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+      if (m) {
+        var word = m[1];
+        if (SN_API_KEYWORDS.indexOf(word) !== -1) {
+          tokens.push({ type: 'sn-api', text: word });
+        } else if (JS_KEYWORDS.indexOf(word) !== -1) {
+          tokens.push({ type: 'keyword', text: word });
+        } else {
+          tokens.push({ type: 'plain', text: word });
+        }
+        remaining = remaining.substring(word.length);
+        matched = true;
+        continue;
+      }
+
+      // Anything else — single character
+      tokens.push({ type: 'plain', text: remaining[0] });
+      remaining = remaining.substring(1);
+    }
+
+    // Build highlighted HTML
+    var html = '';
+    for (var i = 0; i < tokens.length; i++) {
+      var t = tokens[i];
+      var escaped = escapeHtml(t.text);
+      switch (t.type) {
+        case 'comment':
+          html += '<span class="nowaikit-comment">' + escaped + '</span>';
+          break;
+        case 'string':
+          html += '<span class="nowaikit-string">' + escaped + '</span>';
+          break;
+        case 'number':
+          html += '<span class="nowaikit-number">' + escaped + '</span>';
+          break;
+        case 'keyword':
+          html += '<span class="nowaikit-keyword">' + escaped + '</span>';
+          break;
+        case 'sn-api':
+          html += '<span class="nowaikit-sn-api">' + escaped + '</span>';
+          break;
+        default:
+          html += escaped;
+      }
+    }
+
+    return html;
+  }
+
+  function injectScriptHighlighting() {
+    // Target ServiceNow script editor textareas and CodeMirror instances
+    const scriptSelectors = [
+      'textarea.sn-script-editor',
+      'textarea[id^="element."][id$=".script"]',
+      'textarea[name="script"]',
+      'textarea[name="condition"]',
+      '.CodeMirror',
+    ].join(', ');
+
+    waitForElements(scriptSelectors, function(editors) {
+      editors.forEach(function(editor) {
+        applyScriptOverlay(editor);
+      });
+    }, 8000, 1000);
+
+    // Observe for dynamically loaded CodeMirror instances (auto-disconnect after 15s)
+    if (document.body) {
+      var cmObserverTimer;
+      var cmObserver = new MutationObserver(function(mutations) {
+        for (var i = 0; i < mutations.length; i++) {
+          var added = mutations[i].addedNodes;
+          for (var j = 0; j < added.length; j++) {
+            var node = added[j];
+            if (node.nodeType !== 1) continue;
+            if (node.classList && node.classList.contains('CodeMirror')) {
+              applyScriptOverlay(node);
+            }
+            var cms = node.querySelectorAll ? node.querySelectorAll('.CodeMirror') : [];
+            for (var k = 0; k < cms.length; k++) {
+              applyScriptOverlay(cms[k]);
+            }
+          }
+        }
+      });
+      cmObserver.observe(document.body, { childList: true, subtree: true });
+      // Auto-disconnect after 15 seconds to stop observing entire DOM
+      cmObserverTimer = setTimeout(function() { cmObserver.disconnect(); }, 15000);
+    }
+  }
+
+  function applyScriptOverlay(editor) {
+    // Skip if we already attached
+    if (editor.dataset.nowaikitHighlight === 'true') return;
+    editor.dataset.nowaikitHighlight = 'true';
+
+    // For CodeMirror instances
+    if (editor.classList && editor.classList.contains('CodeMirror')) {
+      const cmInstance = editor.CodeMirror;
+      if (!cmInstance) return;
+
+      // Create overlay container
+      const overlay = document.createElement('div');
+      overlay.className = 'nowaikit-script-overlay';
+      overlay.setAttribute('aria-hidden', 'true');
+
+      // Position overlay over the CodeMirror scroll area
+      const scrollEl = editor.querySelector('.CodeMirror-scroll');
+      if (!scrollEl) return;
+
+      scrollEl.style.position = 'relative';
+      scrollEl.appendChild(overlay);
+
+      function updateOverlay() {
+        const code = cmInstance.getValue();
+        overlay.innerHTML = '<pre class="nowaikit-script-pre">' + highlightSyntax(code) + '</pre>';
+      }
+
+      cmInstance.on('change', updateOverlay);
+      updateOverlay();
+      return;
+    }
+
+    // For plain textareas
+    if (editor.tagName === 'TEXTAREA') {
+      const wrapper = editor.parentElement;
+      if (!wrapper) return;
+
+      wrapper.style.position = 'relative';
+
+      const overlay = document.createElement('div');
+      overlay.className = 'nowaikit-script-overlay nowaikit-textarea-overlay';
+      overlay.setAttribute('aria-hidden', 'true');
+      wrapper.appendChild(overlay);
+
+      function updateTextareaOverlay() {
+        overlay.innerHTML = '<pre class="nowaikit-script-pre">' + highlightSyntax(editor.value) + '</pre>';
+
+        // Sync scroll
+        overlay.scrollTop = editor.scrollTop;
+        overlay.scrollLeft = editor.scrollLeft;
+      }
+
+      editor.addEventListener('input', updateTextareaOverlay);
+      editor.addEventListener('scroll', function() {
+        overlay.scrollTop = editor.scrollTop;
+        overlay.scrollLeft = editor.scrollLeft;
+      });
+      updateTextareaOverlay();
+    }
+  }
+
+  // ─── AI Sidebar On-Demand Init ──────────────────────────────────────────────
+
+  /** Initialize AI sidebar on-demand (first call inits, subsequent calls toggle) */
+  function ensureAISidebar() {
+    // Always init first (idempotent — won't re-create if already exists)
+    if (typeof initAISidebar === 'function') {
+      initAISidebar();
+    }
+    if (typeof toggleAISidebar === 'function') {
+      toggleAISidebar();
+    }
+  }
+
+  // ─── Keyboard Shortcuts ─────────────────────────────────────────────────────
+
+  function injectKeyboardShortcuts() {
+    // Helper: check for Ctrl (Windows/Linux) or Cmd (Mac)
+    function modKey(e) { return e.ctrlKey || e.metaKey; }
+
+    document.addEventListener('keydown', function(e) {
+      if (!e.shiftKey || !modKey(e)) return;
+
+      switch (e.key) {
+        case 'K': // Quick Nav
+          e.preventDefault();
+          var nav = document.getElementById('nowaikit-quicknav');
+          if (nav) {
+            nav.style.display = nav.style.display === 'none' ? 'flex' : 'none';
+            if (nav.style.display === 'flex') {
+              var inp = document.getElementById('nowaikit-quicknav-input');
+              if (inp) inp.focus();
+            }
+          }
+          break;
+        case 'C': // Copy sys_id
+          e.preventDefault();
+          if (currentSysId) {
+            safeClipboardWrite(currentSysId, 'sys_id copied!', 'Failed to copy sys_id');
+          }
+          break;
+        case 'U': // Copy URL
+          e.preventDefault();
+          safeClipboardWrite(window.location.href, 'URL copied!', 'Failed to copy URL');
+          break;
+        case 'L': // Open list view
+          e.preventDefault();
+          if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '_list.do', '_blank');
+          }
+          break;
+        case 'X': // View as XML
+          e.preventDefault();
+          if (currentTable && isValidTableName(currentTable) && currentSysId && isValidSysId(currentSysId)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?XML&sys_id=' + encodeURIComponent(currentSysId), '_blank');
+          } else if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?XML', '_blank');
+          }
+          break;
+        case 'J': // View as JSON
+          e.preventDefault();
+          if (currentTable && isValidTableName(currentTable) && currentSysId && isValidSysId(currentSysId)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?JSONv2&sysparm_action=get&sysparm_sys_id=' + encodeURIComponent(currentSysId), '_blank');
+          } else if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?JSONv2&sysparm_action=getRecords&sysparm_limit=20', '_blank');
+          }
+          break;
+        case 'P': // Main Panel
+          e.preventDefault();
+          if (typeof window.toggleMainPanel === 'function') window.toggleMainPanel();
+          break;
+        case 'A': // Toggle AI Sidebar
+          e.preventDefault();
+          ensureAISidebar();
+          break;
+        case 'N': // Node Switcher
+          e.preventDefault();
+          openNodeSwitcher();
+          break;
+      }
+    });
+  }
+
+  // ─── Context Menu Actions ──────────────────────────────────────────────────
+
+  function listenForContextMenuActions() {
+    chrome.runtime.onMessage.addListener(function(message, sender, sendResponse) {
+      // Handle bridge status query from popup
+      if (message.action === 'nowaikit-get-bridge-status') {
+        if (typeof getBridgeStatus === 'function') {
+          sendResponse(getBridgeStatus());
+        } else {
+          sendResponse({ connected: false });
+        }
+        return true; // async response
+      }
+
+      switch (message.action) {
+        case 'nowaikit-copy-sysid':
+          if (currentSysId) {
+            safeClipboardWrite(currentSysId, 'sys_id copied!', 'Failed to copy sys_id');
+          } else {
+            showToast('No sys_id found on this page', 'warn');
+          }
+          break;
+
+        case 'nowaikit-copy-record-url':
+          safeClipboardWrite(window.location.href, 'URL copied!', 'Failed to copy URL');
+          break;
+
+        case 'nowaikit-copy-table-name':
+          if (currentTable) {
+            safeClipboardWrite(currentTable, 'Table name copied!', 'Failed to copy table name');
+          }
+          break;
+
+        case 'nowaikit-open-list':
+          if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '_list.do', '_blank');
+          }
+          break;
+
+        case 'nowaikit-open-schema':
+          if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/sys_dictionary_list.do?sysparm_query=name=' + encodeURIComponent(currentTable), '_blank');
+          }
+          break;
+
+        case 'nowaikit-xml-view':
+          if (currentTable && isValidTableName(currentTable) && currentSysId && isValidSysId(currentSysId)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?XML&sys_id=' + encodeURIComponent(currentSysId), '_blank');
+          } else if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?XML', '_blank');
+          }
+          break;
+
+        case 'nowaikit-json-view':
+          if (currentTable && isValidTableName(currentTable) && currentSysId && isValidSysId(currentSysId)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?JSONv2&sysparm_action=get&sysparm_sys_id=' + encodeURIComponent(currentSysId), '_blank');
+          } else if (currentTable && isValidTableName(currentTable)) {
+            window.open(instanceUrl + '/' + encodeURIComponent(currentTable) + '.do?JSONv2&sysparm_action=getRecords&sysparm_limit=20', '_blank');
+          }
+          break;
+
+        case 'nowaikit-toggle-ai-sidebar':
+          ensureAISidebar();
+          break;
+
+        case 'nowaikit-switch-node':
+          openNodeSwitcher();
+          break;
+
+        case 'nowaikit-toggle-main-panel':
+          if (typeof window.toggleMainPanel === 'function') window.toggleMainPanel();
+          break;
+
+        case 'nowaikit-set-theme':
+          if (message.theme && typeof window.nowaikitSetTheme === 'function') {
+            window.nowaikitSetTheme(message.theme);
+          }
+          break;
+      }
+    });
+  }
+
+  // ─── Toast Notification ────────────────────────────────────────────────────
+
+  // Expose globally for ai-sidebar.js etc.
+  window.showToast = showToast;
+
+  function showToast(message, type) {
+    if (!type) type = 'success';
+    const existing = document.getElementById('nowaikit-toast');
+    if (existing) existing.remove();
+
+    const toast = document.createElement('div');
+    toast.id = 'nowaikit-toast';
+    toast.className = 'nowaikit-toast nowaikit-toast-' + type;
+    toast.textContent = message;
+    document.body.appendChild(toast);
+
+    setTimeout(function() { toast.classList.add('nowaikit-toast-show'); }, 10);
+    setTimeout(function() {
+      toast.classList.remove('nowaikit-toast-show');
+      setTimeout(function() { toast.remove(); }, 300);
+    }, 2000);
+  }
+
+  // ─── Utilities ─────────────────────────────────────────────────────────────
+
+  // Expose globally for ai-sidebar.js, main-panel.js, etc.
+  window.escapeHtml = escapeHtml;
+  window.openNodeSwitcher = openNodeSwitcher;
+  window.ensureAISidebar = ensureAISidebar;
+
+  function escapeHtml(str) {
+    const div = document.createElement('div');
+    div.textContent = str;
+    return div.innerHTML;
+  }
+
+  /**
+   * Safe clipboard write with error handling.
+   * @param {string} text - Text to copy
+   * @param {string} [successMsg] - Toast message on success
+   * @param {string} [failMsg] - Toast message on failure
+   */
+  function safeClipboardWrite(text, successMsg, failMsg) {
+    navigator.clipboard.writeText(text).then(function() {
+      if (successMsg) showToast(successMsg);
+    }).catch(function() {
+      if (failMsg) showToast(failMsg, 'warn');
+    });
+  }
+
+  /**
+   * Validate a ServiceNow table name is safe for URL construction.
+   * Allows only alphanumeric, underscores, and dots.
+   * @param {string} name
+   * @returns {boolean}
+   */
+  function isValidTableName(name) {
+    return /^[a-zA-Z_][a-zA-Z0-9_.]*$/.test(name);
+  }
+
+  /**
+   * Validate a sys_id is a 32-char hex string.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  function isValidSysId(id) {
+    return /^[a-f0-9]{32}$/.test(id);
+  }
+
+  window.safeClipboardWrite = safeClipboardWrite;
+
+})();