nowaikit-utils 1.1.0

package/content/integration-bridge.js

@@ -0,0 +1,627 @@
+/**
+ * NowAIKit Utils — Integration Bridge
+ *
+ * WebSocket client that connects the browser extension to the NowAIKit Builder
+ * VS Code extension, turning the browser extension into part of an integrated
+ * product suite.
+ *
+ * Protocol:
+ *   Browser -> Builder:  { type: 'api-request', id, method, params }
+ *   Builder -> Browser:  { type: 'api-response', id, success, result|error }
+ *   Browser -> Builder:  { type: 'script-change', table, sys_id, field, name, scope, content }
+ *   Builder -> Browser:  { type: 'script-save', table, sys_id, field, name, scope, content }
+ *
+ * Not wrapped in IIFE — functions are exposed globally for content.js and ai-sidebar.js.
+ * Uses `var` and top-level `function` declarations for content script compatibility.
+ */
+
+// ─── Bridge State ──────────────────────────────────────────────
+
+/** @type {WebSocket|null} */
+var _bridgeSocket = null;
+
+/** @type {boolean} */
+var _bridgeConnected = false;
+
+/** @type {string} */
+var _bridgeInstanceName = '';
+
+/** @type {string} */
+var _bridgeInstanceUrl = '';
+
+/** @type {number} */
+var _bridgeReconnectAttempts = 0;
+
+/** @type {number|null} Timer ID for reconnection */
+var _bridgeReconnectTimer = null;
+
+/** @type {number} Configured port (loaded from storage, default 8765) */
+var _bridgePort = 8765;
+
+/** @type {boolean} Whether auto-connect is enabled */
+var _bridgeAutoConnect = true;
+
+/** @type {Map<string, {resolve: Function, reject: Function, timer: number}>} */
+var _bridgePendingRequests = new Map();
+
+/** @type {Function[]} Callbacks fired on connection status changes */
+var _bridgeStatusCallbacks = [];
+
+/** @type {Function[]} Callbacks fired when a script-save message arrives */
+var _scriptSaveCallbacks = [];
+
+/** @type {number} Request timeout in milliseconds */
+var BRIDGE_REQUEST_TIMEOUT = 30000;
+
+/** @type {number} Max fast reconnect attempts before backing off */
+var BRIDGE_MAX_FAST_RECONNECTS = 3;
+
+/** @type {number} Fast reconnect interval in milliseconds */
+var BRIDGE_RECONNECT_FAST = 10000;
+
+/** @type {number} Slow (backoff) reconnect interval in milliseconds */
+var BRIDGE_RECONNECT_SLOW = 30000;
+
+
+// ─── ID Generation ─────────────────────────────────────────────
+
+/**
+ * Generate a unique request ID for correlating request/response pairs.
+ * @returns {string}
+ */
+function _bridgeGenerateId() {
+  return Date.now() + '-' + Math.random().toString(36).substr(2, 9);
+}
+
+
+// ─── Status Change Notifications ───────────────────────────────
+
+/**
+ * Fire all registered status change callbacks with the current state.
+ */
+function _bridgeFireStatusChange() {
+  var status = getBridgeStatus();
+  for (var i = 0; i < _bridgeStatusCallbacks.length; i++) {
+    try {
+      _bridgeStatusCallbacks[i](status);
+    } catch (e) {
+      // Don't let a bad callback break the bridge
+    }
+  }
+}
+
+
+// ─── Connection Management ─────────────────────────────────────
+
+/**
+ * Initialize the integration bridge.
+ *
+ * Loads configuration from chrome.storage and optionally auto-connects
+ * to the NowAIKit Builder VS Code extension WebSocket server.
+ *
+ * @param {Object} [options]
+ * @param {number} [options.port]            - WebSocket port (default: from storage or 8765)
+ * @param {boolean} [options.autoConnect]    - Connect immediately (default: from storage or true)
+ * @param {Function} [options.onStatusChange] - Callback for connection status changes
+ */
+function initIntegrationBridge(options) {
+  options = options || {};
+
+  // Register status change callback if provided
+  if (typeof options.onStatusChange === 'function') {
+    _bridgeStatusCallbacks.push(options.onStatusChange);
+  }
+
+  // Load configuration from chrome.storage, then connect if enabled
+  chrome.storage.local.get({ bridgePort: 8765 }, function(localData) {
+    _bridgePort = options.port || localData.bridgePort || 8765;
+
+    chrome.storage.sync.get({ enableBridgeAutoConnect: true }, function(syncData) {
+      _bridgeAutoConnect = (options.autoConnect !== undefined)
+        ? options.autoConnect
+        : syncData.enableBridgeAutoConnect;
+
+      if (_bridgeAutoConnect) {
+        connectToBridge();
+      }
+    });
+  });
+}
+
+/**
+ * Connect (or reconnect) to the NowAIKit Builder WebSocket server.
+ *
+ * Safe to call multiple times — if already connected, this is a no-op.
+ * On successful connection, immediately queries the Builder for instance info.
+ */
+function connectToBridge() {
+  // Don't open a second socket
+  if (_bridgeSocket && (_bridgeSocket.readyState === WebSocket.CONNECTING || _bridgeSocket.readyState === WebSocket.OPEN)) {
+    return;
+  }
+
+  // Clear any pending reconnect timer
+  if (_bridgeReconnectTimer !== null) {
+    clearTimeout(_bridgeReconnectTimer);
+    _bridgeReconnectTimer = null;
+  }
+
+  var url = 'ws://localhost:' + _bridgePort;
+
+  try {
+    _bridgeSocket = new WebSocket(url);
+  } catch (e) {
+    // WebSocket constructor can throw if URL is invalid or localhost blocked
+    _bridgeConnected = false;
+    _bridgeFireStatusChange();
+    _bridgeScheduleReconnect();
+    return;
+  }
+
+  // ── onopen ──
+
+  _bridgeSocket.onopen = function() {
+    _bridgeConnected = true;
+    _bridgeReconnectAttempts = 0;
+    _bridgeFireStatusChange();
+
+    // Immediately fetch instance info from Builder
+    _bridgeRequest('get_instance_info', {}).then(function(result) {
+      if (result) {
+        _bridgeInstanceName = result.name || result.instanceName || '';
+        _bridgeInstanceUrl = result.url || result.instanceUrl || '';
+        _bridgeFireStatusChange();
+      }
+    }).catch(function() {
+      // Non-fatal — Builder might not have instance info yet
+    });
+  };
+
+  // ── onmessage ──
+
+  _bridgeSocket.onmessage = function(event) {
+    var msg;
+    try {
+      msg = JSON.parse(event.data);
+    } catch (e) {
+      return; // Ignore non-JSON messages
+    }
+
+    if (msg.type === 'api-response') {
+      _bridgeHandleResponse(msg);
+    } else if (msg.type === 'script-save') {
+      _bridgeHandleScriptSave(msg);
+    }
+  };
+
+  // ── onerror ──
+
+  _bridgeSocket.onerror = function() {
+    // Error usually followed by close — actual handling happens in onclose
+  };
+
+  // ── onclose ──
+
+  _bridgeSocket.onclose = function() {
+    var wasConnected = _bridgeConnected;
+    _bridgeConnected = false;
+    _bridgeInstanceName = '';
+    _bridgeInstanceUrl = '';
+    _bridgeSocket = null;
+
+    // Reject all pending requests
+    _bridgePendingRequests.forEach(function(entry) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error('Bridge connection closed'));
+    });
+    _bridgePendingRequests.clear();
+
+    if (wasConnected) {
+      _bridgeFireStatusChange();
+    }
+
+    _bridgeScheduleReconnect();
+  };
+}
+
+/**
+ * Manually disconnect from the Builder WebSocket server.
+ *
+ * Cancels any pending reconnect timer so the bridge stays disconnected
+ * until `connectToBridge()` is called again.
+ */
+function disconnectBridge() {
+  // Cancel reconnect
+  if (_bridgeReconnectTimer !== null) {
+    clearTimeout(_bridgeReconnectTimer);
+    _bridgeReconnectTimer = null;
+  }
+
+  _bridgeReconnectAttempts = 0;
+
+  if (_bridgeSocket) {
+    // Prevent onclose from triggering reconnect
+    _bridgeSocket.onclose = null;
+    _bridgeSocket.onerror = null;
+    _bridgeSocket.close();
+    _bridgeSocket = null;
+  }
+
+  var wasConnected = _bridgeConnected;
+  _bridgeConnected = false;
+  _bridgeInstanceName = '';
+  _bridgeInstanceUrl = '';
+
+  // Reject pending requests
+  _bridgePendingRequests.forEach(function(entry) {
+    clearTimeout(entry.timer);
+    entry.reject(new Error('Bridge manually disconnected'));
+  });
+  _bridgePendingRequests.clear();
+
+  if (wasConnected) {
+    _bridgeFireStatusChange();
+  }
+}
+
+/**
+ * Get the current bridge connection status.
+ *
+ * @returns {{ connected: boolean, instanceName: string, instanceUrl: string }}
+ */
+function getBridgeStatus() {
+  return {
+    connected: _bridgeConnected,
+    instanceName: _bridgeInstanceName,
+    instanceUrl: _bridgeInstanceUrl,
+  };
+}
+
+
+// ─── Reconnection Logic ────────────────────────────────────────
+
+/**
+ * Schedule a reconnection attempt with exponential backoff.
+ *
+ * First 3 attempts use a 10-second interval, then backs off to 30 seconds.
+ */
+function _bridgeScheduleReconnect() {
+  if (_bridgeReconnectTimer !== null) return; // Already scheduled
+
+  _bridgeReconnectAttempts++;
+
+  var delay = (_bridgeReconnectAttempts <= BRIDGE_MAX_FAST_RECONNECTS)
+    ? BRIDGE_RECONNECT_FAST
+    : BRIDGE_RECONNECT_SLOW;
+
+  _bridgeReconnectTimer = setTimeout(function() {
+    _bridgeReconnectTimer = null;
+    connectToBridge();
+  }, delay);
+}
+
+
+// ─── Request / Response Correlation ────────────────────────────
+
+/**
+ * Handle an incoming api-response message from the Builder.
+ *
+ * Matches the response to a pending request by ID, resolves or rejects
+ * the associated Promise, and cleans up the timeout timer.
+ *
+ * @param {{ id: string, success: boolean, result?: *, error?: string }} msg
+ */
+function _bridgeHandleResponse(msg) {
+  var id = msg.id;
+  if (!id || !_bridgePendingRequests.has(id)) return;
+
+  var entry = _bridgePendingRequests.get(id);
+  _bridgePendingRequests.delete(id);
+  clearTimeout(entry.timer);
+
+  if (msg.success) {
+    entry.resolve(msg.result);
+  } else {
+    entry.reject(new Error(msg.error || 'Unknown bridge error'));
+  }
+}
+
+/**
+ * Send an API request to the Builder and return a Promise for the response.
+ *
+ * @param {string} method  - InstanceService method name
+ * @param {Object} params  - Method parameters
+ * @returns {Promise<*>}   - Resolves with the result payload
+ */
+function _bridgeRequest(method, params) {
+  return new Promise(function(resolve, reject) {
+    if (!_bridgeSocket || _bridgeSocket.readyState !== WebSocket.OPEN) {
+      reject(new Error('Bridge not connected'));
+      return;
+    }
+
+    var id = _bridgeGenerateId();
+
+    var timer = setTimeout(function() {
+      if (_bridgePendingRequests.has(id)) {
+        _bridgePendingRequests.delete(id);
+        reject(new Error('Bridge request timed out (' + method + ')'));
+      }
+    }, BRIDGE_REQUEST_TIMEOUT);
+
+    _bridgePendingRequests.set(id, {
+      resolve: resolve,
+      reject: reject,
+      timer: timer,
+    });
+
+    var message = {
+      type: 'api-request',
+      id: id,
+      method: method,
+      params: params || {},
+    };
+
+    try {
+      _bridgeSocket.send(JSON.stringify(message));
+    } catch (e) {
+      _bridgePendingRequests.delete(id);
+      clearTimeout(timer);
+      reject(new Error('Failed to send bridge request: ' + e.message));
+    }
+  });
+}
+
+
+// ─── Script Sync Handling ──────────────────────────────────────
+
+/**
+ * Handle an incoming script-save message from the Builder.
+ *
+ * Attempts to update the corresponding form field in the ServiceNow page
+ * if we are viewing the matching record, then notifies all registered
+ * script-save callbacks.
+ *
+ * @param {{ table: string, sys_id: string, field: string, name: string, scope: string, content: string }} msg
+ */
+function _bridgeHandleScriptSave(msg) {
+  // Try to update the ServiceNow form if we're on the right page
+  _bridgeApplyScriptToPage(msg);
+
+  // Fire registered callbacks
+  for (var i = 0; i < _scriptSaveCallbacks.length; i++) {
+    try {
+      _scriptSaveCallbacks[i](msg);
+    } catch (e) {
+      // Don't let a bad callback break the handler
+    }
+  }
+}
+
+/**
+ * Attempt to apply script content to the current ServiceNow page.
+ *
+ * Checks if we are on a form for the matching table/sys_id, then updates
+ * the field via g_form.setValue(), CodeMirror, or textarea fallback.
+ *
+ * @param {{ table: string, sys_id: string, field: string, content: string }} msg
+ */
+function _bridgeApplyScriptToPage(msg) {
+  // Check if we're on the matching record page
+  // currentTable and currentSysId are defined in content.js
+  if (typeof currentTable === 'undefined' || typeof currentSysId === 'undefined') return;
+  if (!msg.table || !msg.sys_id || !msg.field || typeof msg.content !== 'string') return;
+  if (msg.table !== currentTable || msg.sys_id !== currentSysId) return;
+
+  // Validate field name is a safe identifier (prevent CSS selector injection)
+  if (!/^[a-zA-Z_][a-zA-Z0-9_.]*$/.test(msg.field)) return;
+
+  // Method 1: Use g_form.setValue() if available (most reliable)
+  if (typeof g_form !== 'undefined' && typeof g_form.setValue === 'function') {
+    try {
+      g_form.setValue(msg.field, msg.content);
+      return;
+    } catch (e) {
+      // Fall through to other methods
+    }
+  }
+
+  // Method 2: Find a CodeMirror editor for the field
+  var fieldElement = document.getElementById(msg.field) || document.querySelector('[name="' + msg.field + '"]');
+  if (fieldElement) {
+    // Check if the field has a CodeMirror instance
+    var cmWrapper = fieldElement.closest('.CodeMirror') || (fieldElement.nextElementSibling && fieldElement.nextElementSibling.classList.contains('CodeMirror') ? fieldElement.nextElementSibling : null);
+    if (!cmWrapper) {
+      // Some ServiceNow forms wrap the textarea, and the CM is a sibling
+      var parent = fieldElement.parentElement;
+      if (parent) {
+        cmWrapper = parent.querySelector('.CodeMirror');
+      }
+    }
+
+    if (cmWrapper && cmWrapper.CodeMirror) {
+      try {
+        cmWrapper.CodeMirror.setValue(msg.content);
+        return;
+      } catch (e) {
+        // Fall through
+      }
+    }
+
+    // Method 3: Direct textarea update
+    if (fieldElement.tagName === 'TEXTAREA' || fieldElement.tagName === 'INPUT') {
+      fieldElement.value = msg.content;
+      fieldElement.dispatchEvent(new Event('input', { bubbles: true }));
+      fieldElement.dispatchEvent(new Event('change', { bubbles: true }));
+      return;
+    }
+  }
+}
+
+
+// ─── Public API: ServiceNow Instance Queries ───────────────────
+
+/**
+ * Query records from a ServiceNow table via the Builder's InstanceService.
+ *
+ * @param {string} table   - Table name (e.g. 'incident', 'sys_script')
+ * @param {string} [query] - Encoded query string (e.g. 'active=true^priority=1')
+ * @param {string[]} [fields] - Array of field names to return
+ * @param {number} [limit]  - Maximum records to return
+ * @returns {Promise<Object[]>}
+ */
+function bridgeQueryRecords(table, query, fields, limit) {
+  var params = { table: table };
+  if (query) params.query = query;
+  if (fields) params.fields = fields;
+  if (limit) params.limit = limit;
+  return _bridgeRequest('query_records', params);
+}
+
+/**
+ * Get a single record by sys_id via the Builder's InstanceService.
+ *
+ * @param {string} table    - Table name
+ * @param {string} sysId    - Record sys_id
+ * @param {string[]} [fields] - Array of field names to return
+ * @returns {Promise<Object>}
+ */
+function bridgeGetRecord(table, sysId, fields) {
+  var params = { table: table, sys_id: sysId };
+  if (fields) params.fields = fields;
+  return _bridgeRequest('get_record', params);
+}
+
+/**
+ * Get the schema (field definitions) for a ServiceNow table.
+ *
+ * @param {string} table - Table name
+ * @returns {Promise<Object>}
+ */
+function bridgeGetTableSchema(table) {
+  return _bridgeRequest('get_table_schema', { table: table });
+}
+
+/**
+ * Get update sets, optionally filtered by state.
+ *
+ * @param {string} [state] - Filter by state (e.g. 'in progress', 'complete')
+ * @returns {Promise<Object[]>}
+ */
+function bridgeGetUpdateSets(state) {
+  var params = {};
+  if (state) params.state = state;
+  return _bridgeRequest('get_update_sets', params);
+}
+
+/**
+ * Get scripts from the instance, filtered by table type and scope.
+ *
+ * @param {string} [tableType] - Script table (e.g. 'sys_script', 'sys_script_include')
+ * @param {string} [scope]     - Application scope
+ * @returns {Promise<Object[]>}
+ */
+function bridgeGetScripts(tableType, scope) {
+  var params = {};
+  if (tableType) params.table_type = tableType;
+  if (scope) params.scope = scope;
+  return _bridgeRequest('get_scripts', params);
+}
+
+/**
+ * Execute a server-side script on the instance (background script).
+ *
+ * @param {string} script  - Script body to execute
+ * @param {string} [scope] - Application scope to run in
+ * @returns {Promise<Object>}
+ */
+function bridgeExecuteScript(script, scope) {
+  var params = { script: script };
+  if (scope) params.scope = scope;
+  return _bridgeRequest('execute_script', params);
+}
+
+/**
+ * Get instance health information (node status, stats, etc.).
+ *
+ * @returns {Promise<Object>}
+ */
+function bridgeGetInstanceHealth() {
+  return _bridgeRequest('get_instance_health', {});
+}
+
+/**
+ * Get instance identification info (name, URL, version, etc.).
+ *
+ * @returns {Promise<Object>}
+ */
+function bridgeGetInstanceInfo() {
+  return _bridgeRequest('get_instance_info', {});
+}
+
+/**
+ * Search for scripts matching a query across one or more script tables.
+ *
+ * @param {string} [table]    - Script table to search (e.g. 'sys_script_include')
+ * @param {string} [query]    - Search text or encoded query
+ * @param {string[]} [fields] - Fields to return
+ * @param {number} [limit]    - Maximum results
+ * @returns {Promise<Object[]>}
+ */
+function bridgeSearchScripts(table, query, fields, limit) {
+  var params = {};
+  if (table) params.table = table;
+  if (query) params.query = query;
+  if (fields) params.fields = fields;
+  if (limit) params.limit = limit;
+  return _bridgeRequest('search_scripts', params);
+}
+
+
+// ─── Public API: Script Sync ───────────────────────────────────
+
+/**
+ * Send a script-change message to the Builder, notifying it that
+ * a script has been modified in the browser.
+ *
+ * @param {string} table   - Table name (e.g. 'sys_script_include')
+ * @param {string} sysId   - Record sys_id
+ * @param {string} field   - Field name (e.g. 'script')
+ * @param {string} name    - Record display name
+ * @param {string} scope   - Application scope
+ * @param {string} content - Updated script content
+ */
+function bridgeSendScriptChange(table, sysId, field, name, scope, content) {
+  if (!_bridgeSocket || _bridgeSocket.readyState !== WebSocket.OPEN) {
+    return; // Silently skip if not connected
+  }
+
+  var message = {
+    type: 'script-change',
+    table: table,
+    sys_id: sysId,
+    field: field,
+    name: name,
+    scope: scope,
+    content: content,
+  };
+
+  try {
+    _bridgeSocket.send(JSON.stringify(message));
+  } catch (e) {
+    // Silently fail — connection may have just dropped
+  }
+}
+
+/**
+ * Register a callback to be invoked when a script-save message arrives
+ * from the Builder (indicating a script was saved in VS Code).
+ *
+ * @param {Function} callback - Called with the script-save message object:
+ *   { table, sys_id, field, name, scope, content }
+ */
+function onBridgeScriptSave(callback) {
+  if (typeof callback === 'function') {
+    _scriptSaveCallbacks.push(callback);
+  }
+}