nowaikit-utils 1.1.0

package/background/service-worker.js

@@ -0,0 +1,398 @@
+/**
+ * NowAIKit Utils — Background Service Worker
+ *
+ * Handles context menus, badge updates, cookie proxy, and AI streaming.
+ */
+
+// ─── Helpers ───────────────────────────────────────────────────────────────
+
+/** Validate a URL belongs to a ServiceNow domain */
+function isServiceNowUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.endsWith('.service-now.com') || parsed.hostname.endsWith('.servicenow.com');
+  } catch (e) {
+    return false;
+  }
+}
+
+// ─── Context Menus ──────────────────────────────────────────────────────────
+
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.contextMenus.create({
+    id: 'nowaikit-copy-sysid',
+    title: 'Copy sys_id',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-copy-record-url',
+    title: 'Copy Record URL',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-copy-table-name',
+    title: 'Copy Table Name',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-open-list',
+    title: 'Open Table List View',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-open-schema',
+    title: 'View Table Schema',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-separator',
+    type: 'separator',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-xml-view',
+    title: 'View as XML',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+
+  chrome.contextMenus.create({
+    id: 'nowaikit-json-view',
+    title: 'View as JSON (REST)',
+    contexts: ['page'],
+    documentUrlPatterns: ['https://*.service-now.com/*', 'https://*.servicenow.com/*'],
+  });
+});
+
+chrome.contextMenus.onClicked.addListener((info, tab) => {
+  if (!tab?.id) return;
+
+  chrome.tabs.sendMessage(tab.id, {
+    action: info.menuItemId,
+  });
+});
+
+// ─── Badge Updates ──────────────────────────────────────────────────────────
+
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  if (changeInfo.status !== 'complete') return;
+  if (!tab.url) return;
+
+  if (isServiceNowUrl(tab.url)) {
+    chrome.action.setBadgeText({ text: 'ON', tabId });
+    chrome.action.setBadgeBackgroundColor({ color: '#00D4AA', tabId });
+  } else {
+    chrome.action.setBadgeText({ text: '', tabId });
+  }
+});
+
+// ─── Message Handler ────────────────────────────────────────────────────────
+
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  // Security: only accept messages from our own extension
+  if (sender.id !== chrome.runtime.id) return;
+
+  if (message.action === 'getSettings') {
+    chrome.storage.sync.get({
+      showTechnicalNames: false,
+      showUpdateSetBanner: false,
+      showFieldTypes: false,
+      enableNodeSwitcher: false,
+      enableQuickNav: false,
+      enableScriptHighlight: false,
+      enableFieldCopy: false,
+      enableAISidebar: false,
+      darkOverlay: false,
+    }, (settings) => {
+      sendResponse(settings);
+    });
+    return true;
+  }
+
+  if (message.action === 'openUrl') {
+    // Validate URL is a ServiceNow domain
+    if (isServiceNowUrl(message.url)) {
+      chrome.tabs.create({ url: message.url });
+    }
+  }
+
+  // ─── Cookie Handlers (for Node Switcher) ───────────────────────────────
+  // Content scripts can't set httpOnly cookies — must go through background
+
+  if (message.action === 'setCookie') {
+    // Security: only allow cookie ops on ServiceNow domains
+    if (!isServiceNowUrl(message.url)) {
+      sendResponse({ success: false, error: 'Invalid domain' });
+      return true;
+    }
+    const opts = {
+      url: message.url,
+      name: message.name,
+      value: message.value,
+      path: message.path || '/',
+    };
+    if (message.domain) opts.domain = message.domain;
+    if (message.httpOnly !== undefined) opts.httpOnly = message.httpOnly;
+    if (message.secure !== undefined) opts.secure = message.secure;
+    if (message.sameSite) opts.sameSite = message.sameSite;
+    if (message.expirationDate) {
+      opts.expirationDate = message.expirationDate;
+    } else {
+      opts.expirationDate = Math.floor(Date.now() / 1000) + 86400 * 365;
+    }
+    chrome.cookies.set(opts, (cookie) => {
+      sendResponse({ success: !!cookie, cookie: cookie });
+    });
+    return true;
+  }
+
+  if (message.action === 'getCookie') {
+    if (!isServiceNowUrl(message.url)) {
+      sendResponse({ cookie: null });
+      return true;
+    }
+    chrome.cookies.get({ url: message.url, name: message.name }, (cookie) => {
+      sendResponse({ cookie: cookie });
+    });
+    return true;
+  }
+
+  if (message.action === 'getAllCookies') {
+    if (!isServiceNowUrl(message.url)) {
+      sendResponse({ cookies: [] });
+      return true;
+    }
+    chrome.cookies.getAll({ url: message.url }, (cookies) => {
+      sendResponse({ cookies: cookies || [] });
+    });
+    return true;
+  }
+
+  if (message.action === 'removeCookie') {
+    if (!isServiceNowUrl(message.url)) {
+      sendResponse({ success: false });
+      return true;
+    }
+    chrome.cookies.remove({ url: message.url, name: message.name }, (details) => {
+      sendResponse({ success: !!details });
+    });
+    return true;
+  }
+});
+
+// ─── AI Chat: LLM API Proxy with Streaming ─────────────────────────────────
+
+chrome.runtime.onConnect.addListener((port) => {
+  if (port.name !== 'nowaikit-ai-stream') return;
+
+  let aborted = false;
+  let activeReader = null;
+
+  // Handle port disconnect — abort streaming
+  port.onDisconnect.addListener(() => {
+    aborted = true;
+    if (activeReader) {
+      try { activeReader.cancel(); } catch (e) { /* ignore */ }
+    }
+  });
+
+  port.onMessage.addListener(async (msg) => {
+    if (msg.action !== 'nowaikit-ai-chat') return;
+
+    const { provider, apiKey, model, messages, ollamaUrl } = msg;
+
+    try {
+      let url, headers, body;
+
+      switch (provider) {
+        case 'anthropic':
+          url = 'https://api.anthropic.com/v1/messages';
+          headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'anthropic-dangerous-direct-browser-access': 'true',
+          };
+          const systemMsg = messages.find(m => m.role === 'system');
+          const nonSystemMsgs = messages.filter(m => m.role !== 'system');
+          body = JSON.stringify({
+            model: model,
+            max_tokens: 4096,
+            system: systemMsg ? systemMsg.content : '',
+            messages: nonSystemMsgs,
+            stream: true,
+          });
+          break;
+
+        case 'google':
+          url = 'https://generativelanguage.googleapis.com/v1beta/models/' + encodeURIComponent(model) + ':streamGenerateContent?alt=sse';
+          headers = {
+            'Content-Type': 'application/json',
+            'x-goog-api-key': apiKey,
+          };
+          const googleContents = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+              role: m.role === 'assistant' ? 'model' : 'user',
+              parts: [{ text: m.content }],
+            }));
+          const googleSystem = messages.find(m => m.role === 'system');
+          body = JSON.stringify({
+            contents: googleContents,
+            systemInstruction: googleSystem ? { parts: [{ text: googleSystem.content }] } : undefined,
+          });
+          break;
+
+        case 'ollama':
+          url = (ollamaUrl || 'http://localhost:11434') + '/api/chat';
+          headers = { 'Content-Type': 'application/json' };
+          body = JSON.stringify({
+            model: model,
+            messages: messages,
+            stream: true,
+          });
+          break;
+
+        case 'openrouter':
+          url = 'https://openrouter.ai/api/v1/chat/completions';
+          headers = {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + apiKey,
+            'HTTP-Referer': 'https://nowaikit.com',
+            'X-Title': 'NowAIKit Utils',
+          };
+          body = JSON.stringify({
+            model: model,
+            messages: messages,
+            stream: true,
+          });
+          break;
+
+        case 'openai':
+        default:
+          url = 'https://api.openai.com/v1/chat/completions';
+          headers = {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + apiKey,
+          };
+          body = JSON.stringify({
+            model: model,
+            messages: messages,
+            stream: true,
+          });
+          break;
+      }
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: headers,
+        body: body,
+      });
+
+      if (!response.ok) {
+        const errText = await response.text();
+        let errMsg = 'API error (' + response.status + ')';
+        try {
+          const errJson = JSON.parse(errText);
+          errMsg = errJson.error?.message || errJson.message || errMsg;
+        } catch (e) {
+          errMsg = errText.substring(0, 200) || errMsg;
+        }
+        if (!aborted) {
+          try { port.postMessage({ type: 'error', content: errMsg }); } catch (e) { /* port closed */ }
+        }
+        return;
+      }
+
+      // Stream the response
+      const reader = response.body.getReader();
+      activeReader = reader;
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (!aborted) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (aborted) break;
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === 'data: [DONE]') continue;
+
+          try {
+            let json;
+            let token = '';
+
+            if (provider === 'ollama') {
+              json = JSON.parse(trimmed);
+              if (json.message?.content) {
+                token = json.message.content;
+              }
+            } else {
+              if (!trimmed.startsWith('data: ')) continue;
+              json = JSON.parse(trimmed.slice(6));
+
+              if (provider === 'anthropic') {
+                if (json.type === 'content_block_delta' && json.delta?.text) {
+                  token = json.delta.text;
+                }
+              } else if (provider === 'google') {
+                if (json.candidates?.[0]?.content?.parts?.[0]?.text) {
+                  token = json.candidates[0].content.parts[0].text;
+                }
+              } else {
+                if (json.choices?.[0]?.delta?.content) {
+                  token = json.choices[0].delta.content;
+                }
+              }
+            }
+
+            if (token && !aborted) {
+              try { port.postMessage({ type: 'token', content: token }); } catch (e) { aborted = true; break; }
+            }
+          } catch (e) {
+            // Skip malformed JSON lines
+          }
+        }
+      }
+
+      // Handle remaining buffer for Ollama
+      if (!aborted && provider === 'ollama' && buffer.trim()) {
+        try {
+          const json = JSON.parse(buffer.trim());
+          if (json.message?.content) {
+            try { port.postMessage({ type: 'token', content: json.message.content }); } catch (e) { /* port closed */ }
+          }
+        } catch (e) {
+          // Ignore
+        }
+      }
+
+      activeReader = null;
+      if (!aborted) {
+        try { port.postMessage({ type: 'done' }); } catch (e) { /* port closed */ }
+      }
+
+    } catch (err) {
+      if (!aborted) {
+        try { port.postMessage({ type: 'error', content: err.message || 'Failed to connect to AI provider' }); } catch (e) { /* port closed */ }
+      }
+    }
+  });
+});

package/cli.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import { readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, 'package.json'), 'utf8'));
+
+const TEAL = '\x1b[36m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+
+console.log(`
+${TEAL}${BOLD}  _   _                 _    ___ _  ___ _
+ | \\ | | _____      __/ \\  |_ _| |/ (_) |_
+ |  \\| |/ _ \\ \\ /\\ / / _ \\  | || ' /| | __|
+ | |\\  | (_) \\ V  V / ___ \\ | || . \\| | |_
+ |_| \\_|\\___/ \\_/\\_/_/   \\_\\___|_|\\_\\_|\\__|
+                                    ${DIM}Utils${RESET}
+${TEAL}${BOLD} The AI-Powered ServiceNow Browser Extension${RESET}
+${DIM} v${pkg.version}${RESET}
+`);
+
+console.log(`${BOLD}Features:${RESET}
+  ${GREEN}+${RESET} AI Assistant with 5 providers (OpenAI, Anthropic, Google, OpenRouter, Ollama)
+  ${GREEN}+${RESET} 22 code templates (GlideRecord, GlideQuery, Business Rules, REST, etc.)
+  ${GREEN}+${RESET} 12 slash commands for instant navigation
+  ${GREEN}+${RESET} 10 keyboard shortcuts for zero-mouse workflow
+  ${GREEN}+${RESET} Node switcher with cluster-aware discovery
+  ${GREEN}+${RESET} Two-way script sync with VS Code (NowAIKit Builder)
+  ${GREEN}+${RESET} Multi-instance management with color-coded environments
+  ${GREEN}+${RESET} Technical name resolver, field copy, syntax highlighting
+  ${GREEN}+${RESET} AES-256-GCM encrypted API key storage
+  ${GREEN}+${RESET} Zero telemetry, domain-scoped, CSP enforced
+`);
+
+console.log(`${BOLD}Installation:${RESET}
+
+  ${YELLOW}Option 1: Chrome Web Store${RESET}
+  Visit: https://chrome.google.com/webstore/detail/nowaikit-utils
+
+  ${YELLOW}Option 2: Load Unpacked (Developer Mode)${RESET}
+  1. Extension files are installed at:
+     ${TEAL}${resolve(__dirname)}${RESET}
+  2. Open Chrome and navigate to: ${TEAL}chrome://extensions${RESET}
+  3. Enable ${BOLD}Developer mode${RESET} (toggle in top-right)
+  4. Click ${BOLD}Load unpacked${RESET}
+  5. Select the directory above
+`);
+
+console.log(`${BOLD}Part of the NowAIKit Ecosystem:${RESET}
+  ${DIM}NowAIKit MCP${RESET}     — 400+ tools, connect any AI to ServiceNow
+  ${DIM}NowAIKit Builder${RESET}  — VS Code extension with 10 Copilot agents
+  ${TEAL}NowAIKit Utils${RESET}   — Chrome extension (you are here)
+  ${DIM}NowAIKit Apex${RESET}    — CLI with 26 scan/review/build capabilities
+`);
+
+console.log(`${DIM}GitHub:  https://github.com/aartiq/nowaikit-utils-browser${RESET}`);
+console.log(`${DIM}Website: https://nowaikit.com/products/utils${RESET}`);
+console.log(`${DIM}npm:     https://www.npmjs.com/package/nowaikit-utils${RESET}`);
+console.log();