@mseep/anything-analyzer 3.6.50

package/src/preload/index.ts

@@ -0,0 +1,211 @@
+import { contextBridge, ipcRenderer } from "electron";
+
+// Forward JS hook messages from the target page context to the main process.
+// The hook script (injected via executeJavaScript) uses window.postMessage
+// to send captured data; we relay it over IPC.
+window.addEventListener("message", (event) => {
+  if (event.data?.type === "ar-hook") {
+    ipcRenderer.send("capture:hook-data", event.data);
+  }
+  if (event.data?.type === "ar-interaction") {
+    ipcRenderer.send("capture:hook-data", event.data);
+  }
+});
+
+// Expose IPC APIs to renderer
+contextBridge.exposeInMainWorld("electronAPI", {
+  // Window control (frameless window)
+  minimizeWindow: () => ipcRenderer.invoke("window:minimize"),
+  maximizeWindow: () => ipcRenderer.invoke("window:maximize"),
+  closeWindow: () => ipcRenderer.invoke("window:close"),
+  isWindowMaximized: () => ipcRenderer.invoke("window:isMaximized"),
+
+  // Session management
+  createSession: (name: string, targetUrl: string) =>
+    ipcRenderer.invoke("session:create", name, targetUrl),
+  listSessions: () => ipcRenderer.invoke("session:list"),
+  startCapture: (sessionId: string) =>
+    ipcRenderer.invoke("session:start", sessionId),
+  pauseCapture: (sessionId: string) =>
+    ipcRenderer.invoke("session:pause", sessionId),
+  resumeCapture: (sessionId: string) =>
+    ipcRenderer.invoke("session:resume", sessionId),
+  stopCapture: (sessionId: string) =>
+    ipcRenderer.invoke("session:stop", sessionId),
+  deleteSession: (sessionId: string) =>
+    ipcRenderer.invoke("session:delete", sessionId),
+
+  // Browser control
+  navigate: (url: string) => ipcRenderer.invoke("browser:navigate", url),
+  goBack: () => ipcRenderer.invoke("browser:back"),
+  goForward: () => ipcRenderer.invoke("browser:forward"),
+  reload: () => ipcRenderer.invoke("browser:reload"),
+  setBrowserRatio: (ratio: number) =>
+    ipcRenderer.invoke("browser:setRatio", ratio),
+  setTargetViewVisible: (visible: boolean) =>
+    ipcRenderer.invoke("browser:setVisible", visible),
+  toggleDevTools: () => ipcRenderer.invoke("browser:toggleDevTools"),
+  exportFile: (defaultName: string, content: string) =>
+    ipcRenderer.invoke("dialog:exportFile", defaultName, content),
+
+  // Shell
+  openExternal: (url: string) => ipcRenderer.invoke("shell:openExternal", url),
+
+  // Tab management
+  createTab: (url?: string) => ipcRenderer.invoke("tabs:create", url),
+  closeTab: (tabId: string) => ipcRenderer.invoke("tabs:close", tabId),
+  activateTab: (tabId: string) => ipcRenderer.invoke("tabs:activate", tabId),
+  listTabs: () => ipcRenderer.invoke("tabs:list"),
+
+  // Data queries
+  getRequests: (sessionId: string) =>
+    ipcRenderer.invoke("data:requests", sessionId),
+  getHooks: (sessionId: string) => ipcRenderer.invoke("data:hooks", sessionId),
+  getStorage: (sessionId: string) =>
+    ipcRenderer.invoke("data:storage", sessionId),
+  getReports: (sessionId: string) =>
+    ipcRenderer.invoke("data:reports", sessionId),
+  clearCaptureData: (sessionId: string) =>
+    ipcRenderer.invoke("data:clear", sessionId),
+
+  // AI analysis
+  startAnalysis: (sessionId: string, purpose?: string, selectedSeqs?: number[]) =>
+    ipcRenderer.invoke("ai:analyze", sessionId, purpose, selectedSeqs),
+  cancelAnalysis: (sessionId: string) =>
+    ipcRenderer.invoke("ai:cancel", sessionId),
+  sendFollowUp: (sessionId: string, reportId: string, history: unknown[], userMessage: string) =>
+    ipcRenderer.invoke("ai:chat", sessionId, reportId, history, userMessage),
+  getChatMessages: (reportId: string) =>
+    ipcRenderer.invoke("data:chatMessages", reportId),
+  saveChatMessages: (reportId: string, messages: unknown[]) =>
+    ipcRenderer.invoke("data:saveChatMessages", reportId, messages),
+
+  // Browser bounds sync (renderer → main, fire-and-forget)
+  syncBrowserBounds: (bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }) => ipcRenderer.send("browser:syncBounds", bounds),
+
+  // Settings
+  getLLMConfig: () => ipcRenderer.invoke("settings:getLLM"),
+  saveLLMConfig: (config: unknown) =>
+    ipcRenderer.invoke("settings:saveLLM", config),
+
+  // Auto update
+  getAppVersion: () => ipcRenderer.invoke("app:version"),
+  checkForUpdate: () => ipcRenderer.invoke("update:check"),
+  installUpdate: () => ipcRenderer.send("update:install"),
+  onUpdateStatus: (callback: (status: unknown) => void) => {
+    ipcRenderer.on("update:status", (_event, status) => callback(status));
+  },
+
+  // Prompt Templates
+  getPromptTemplates: () => ipcRenderer.invoke("templates:list"),
+  savePromptTemplate: (template: unknown) =>
+    ipcRenderer.invoke("templates:save", template),
+  deletePromptTemplate: (id: string) =>
+    ipcRenderer.invoke("templates:delete", id),
+  resetPromptTemplate: (id: string) =>
+    ipcRenderer.invoke("templates:reset", id),
+
+  // MCP Servers
+  getMCPServers: () => ipcRenderer.invoke("mcp:list"),
+  saveMCPServer: (server: unknown) => ipcRenderer.invoke("mcp:save", server),
+  deleteMCPServer: (id: string) => ipcRenderer.invoke("mcp:delete", id),
+
+  // Export requests
+  exportRequests: (sessionId: string) =>
+    ipcRenderer.invoke("data:exportRequests", sessionId),
+
+  // AI Request Logs
+  getAiRequestLogs: (sessionId: string) => ipcRenderer.invoke("data:aiRequestLogs", sessionId),
+  getAiRequestLogsAll: (limit: number, offset: number) => ipcRenderer.invoke("data:aiRequestLogsAll", limit, offset),
+  getAiRequestLogDetail: (id: number) => ipcRenderer.invoke("data:aiRequestLogDetail", id),
+
+  // Proxy
+  getProxyConfig: () => ipcRenderer.invoke("proxy:get"),
+  saveProxyConfig: (config: unknown) =>
+    ipcRenderer.invoke("proxy:save", config),
+
+  // Browser environment
+  clearBrowserEnv: () => ipcRenderer.invoke("browser:clearEnv"),
+
+  // MCP Server
+  getMCPServerConfig: () => ipcRenderer.invoke("mcp-server:getConfig"),
+  saveMCPServerConfig: (config: unknown) =>
+    ipcRenderer.invoke("mcp-server:saveConfig", config),
+  getMCPServerStatus: () => ipcRenderer.invoke("mcp-server:status"),
+
+  // MITM Proxy
+  getMitmProxyConfig: () => ipcRenderer.invoke("mitm-proxy:getConfig"),
+  saveMitmProxyConfig: (config: unknown) => ipcRenderer.invoke("mitm-proxy:saveConfig", config),
+  getMitmProxyStatus: () => ipcRenderer.invoke("mitm-proxy:status"),
+  installMitmCA: () => ipcRenderer.invoke("mitm-proxy:installCA"),
+  uninstallMitmCA: () => ipcRenderer.invoke("mitm-proxy:uninstallCA"),
+  exportMitmCA: () => ipcRenderer.invoke("mitm-proxy:exportCA"),
+  regenerateMitmCA: () => ipcRenderer.invoke("mitm-proxy:regenerateCA"),
+  enableMitmSystemProxy: () => ipcRenderer.invoke("mitm-proxy:enableSystemProxy"),
+  disableMitmSystemProxy: () => ipcRenderer.invoke("mitm-proxy:disableSystemProxy"),
+
+  // Interaction Recording
+  getInteractions: (sessionId: string, limit?: number) =>
+    ipcRenderer.invoke("interaction:getEvents", sessionId, limit),
+  getInteractionCount: (sessionId: string) =>
+    ipcRenderer.invoke("interaction:getCount", sessionId),
+  clearInteractions: (sessionId: string) =>
+    ipcRenderer.invoke("interaction:clear", sessionId),
+  onInteractionRecorded: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("interaction:recorded", (_event, data) => callback(data));
+  },
+
+  // Fingerprint
+  getFingerprintProfile: (sessionId: string) =>
+    ipcRenderer.invoke("fingerprint:get", sessionId),
+  updateFingerprintProfile: (profile: unknown) =>
+    ipcRenderer.invoke("fingerprint:update", JSON.stringify(profile)),
+  regenerateFingerprintProfile: (sessionId: string) =>
+    ipcRenderer.invoke("fingerprint:regenerate", sessionId),
+  enableFingerprint: (sessionId: string) =>
+    ipcRenderer.invoke("fingerprint:enable", sessionId),
+  disableFingerprint: () =>
+    ipcRenderer.invoke("fingerprint:disable"),
+
+  // Tab events
+  onTabCreated: (callback: (tab: unknown) => void) => {
+    ipcRenderer.on("tabs:created", (_event, data) => callback(data));
+  },
+  onTabClosed: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("tabs:closed", (_event, data) => callback(data));
+  },
+  onTabActivated: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("tabs:activated", (_event, data) => callback(data));
+  },
+  onTabUpdated: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("tabs:updated", (_event, data) => callback(data));
+  },
+
+  // Events from main process
+  onRequestCaptured: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("capture:request", (_event, data) => callback(data));
+  },
+  onHookCaptured: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("capture:hook", (_event, data) => callback(data));
+  },
+  onStorageCaptured: (callback: (data: unknown) => void) => {
+    ipcRenderer.on("capture:storage", (_event, data) => callback(data));
+  },
+  onAnalysisProgress: (callback: (chunk: string) => void) => {
+    ipcRenderer.on("ai:progress", (_event, chunk) => callback(chunk));
+  },
+
+  // Log files
+  getLogPath: () => ipcRenderer.invoke("log:getPath"),
+  openLogFolder: () => ipcRenderer.invoke("log:openFolder"),
+  exportLogs: () => ipcRenderer.invoke("log:export"),
+
+  removeAllListeners: (channel: string) => {
+    ipcRenderer.removeAllListeners(channel);
+  },
+});

package/src/preload/interaction-hook.ts

@@ -0,0 +1,286 @@
+/**
+ * Interaction recording hook script injected into the target browser page context.
+ * Records clicks, inputs, scrolls, and mouse movement for AI automation replay.
+ */
+;(function () {
+  const MSG_TYPE = 'ar-interaction'
+  let isRecording = false
+
+  // Mouse move sampling config
+  const MOVE_SAMPLE_INTERVAL = 50    // ms between samples
+  const MOVE_FLUSH_INTERVAL = 2000   // ms, flush buffer every 2s
+  const IDLE_THRESHOLD = 500         // ms, end trace segment on idle
+  const MIN_MOVE_DISTANCE = 5        // px, ignore micro-movements
+
+  let moveBuffer: Array<{ x: number; y: number; t: number }> = []
+  let lastMoveTime = 0
+  let lastMoveX = 0
+  let lastMoveY = 0
+  let moveFlushTimer: ReturnType<typeof setTimeout> | null = null
+
+  // Input debounce
+  const inputTimers = new WeakMap<Element, ReturnType<typeof setTimeout>>()
+
+  // Control: main process toggles recording via executeJavaScript
+  window.addEventListener('message', (e) => {
+    if (e.data?.type === 'ar-interaction-control') {
+      isRecording = e.data.recording
+      if (!isRecording) {
+        flushMoveBuffer()
+      }
+    }
+  })
+
+  function send(data: Record<string, unknown>): void {
+    try {
+      window.postMessage({ type: MSG_TYPE, ...data }, '*')
+    } catch { /* ignore serialization errors */ }
+  }
+
+  // ---- Selector Generation ----
+
+  function isDynamicId(id: string): boolean {
+    return /[0-9a-f]{8,}|_\d+$|^:r\d+:|^ember\d+|^react-|^mui-/.test(id)
+  }
+
+  function getSelector(el: Element): string {
+    // Priority 1: stable id
+    if (el.id && !isDynamicId(el.id)) {
+      return `#${CSS.escape(el.id)}`
+    }
+    // Priority 2: test attributes
+    for (const attr of ['data-testid', 'data-cy', 'data-test', 'aria-label', 'data-id']) {
+      const val = el.getAttribute(attr)
+      if (val) {
+        return `[${attr}="${CSS.escape(val)}"]`
+      }
+    }
+    // Priority 3: unique tag + class combination
+    const tag = el.tagName.toLowerCase()
+    if (el.className && typeof el.className === 'string') {
+      const classes = el.className.trim().split(/\s+/).filter(c => !isDynamicId(c)).slice(0, 3)
+      if (classes.length > 0) {
+        const sel = `${tag}.${classes.map(c => CSS.escape(c)).join('.')}`
+        if (document.querySelectorAll(sel).length === 1) {
+          return sel
+        }
+      }
+    }
+    // Priority 4: nth-child path
+    return buildNthChildPath(el)
+  }
+
+  function buildNthChildPath(el: Element): string {
+    const parts: string[] = []
+    let current: Element | null = el
+    while (current && current !== document.documentElement) {
+      const tag = current.tagName.toLowerCase()
+      const parent = current.parentElement
+      if (!parent) {
+        parts.unshift(tag)
+        break
+      }
+      const sameTagSiblings = Array.from(parent.children).filter(c => c.tagName === current!.tagName)
+      if (sameTagSiblings.length === 1) {
+        parts.unshift(tag)
+      } else {
+        const index = sameTagSiblings.indexOf(current) + 1
+        parts.unshift(`${tag}:nth-of-type(${index})`)
+      }
+      current = parent
+      if (parts.length >= 5) break // limit depth
+    }
+    return parts.join(' > ')
+  }
+
+  function getXPath(el: Element): string {
+    const parts: string[] = []
+    let current: Element | null = el
+    while (current && current.nodeType === Node.ELEMENT_NODE) {
+      let index = 1
+      let sibling: Element | null = current.previousElementSibling
+      while (sibling) {
+        if (sibling.tagName === current.tagName) index++
+        sibling = sibling.previousElementSibling
+      }
+      const tag = current.tagName.toLowerCase()
+      parts.unshift(`${tag}[${index}]`)
+      current = current.parentElement
+      if (parts.length >= 7) break
+    }
+    return '//' + parts.join('/')
+  }
+
+  function getAttributes(el: Element): Record<string, string> {
+    const attrs: Record<string, string> = {}
+    const keys = ['id', 'class', 'name', 'type', 'href', 'src', 'placeholder', 'role', 'aria-label',
+      'data-testid', 'data-id', 'data-action', 'value', 'title', 'alt']
+    for (const key of keys) {
+      const val = el.getAttribute(key)
+      if (val) attrs[key] = val.slice(0, 200) // truncate long values
+    }
+    return attrs
+  }
+
+  // ---- Event Handlers ----
+
+  // Click
+  document.addEventListener('click', (e: MouseEvent) => {
+    if (!isRecording) return
+    const el = e.target as Element
+    if (!el) return
+    send({
+      interactionType: 'click',
+      timestamp: Date.now(),
+      x: e.pageX,
+      y: e.pageY,
+      viewportX: e.clientX,
+      viewportY: e.clientY,
+      selector: getSelector(el),
+      xpath: getXPath(el),
+      tagName: el.tagName.toLowerCase(),
+      elementText: (el.textContent || '').trim().slice(0, 100),
+      attributes: getAttributes(el),
+      boundingRect: el.getBoundingClientRect().toJSON(),
+      url: location.href,
+      pageTitle: document.title,
+    })
+  }, true)
+
+  // Double click
+  document.addEventListener('dblclick', (e: MouseEvent) => {
+    if (!isRecording) return
+    const el = e.target as Element
+    if (!el) return
+    send({
+      interactionType: 'dblclick',
+      timestamp: Date.now(),
+      x: e.pageX,
+      y: e.pageY,
+      viewportX: e.clientX,
+      viewportY: e.clientY,
+      selector: getSelector(el),
+      xpath: getXPath(el),
+      tagName: el.tagName.toLowerCase(),
+      elementText: (el.textContent || '').trim().slice(0, 100),
+      attributes: getAttributes(el),
+      boundingRect: el.getBoundingClientRect().toJSON(),
+      url: location.href,
+      pageTitle: document.title,
+    })
+  }, true)
+
+  // Input (debounced — record final value after 500ms idle)
+  document.addEventListener('input', (e: Event) => {
+    if (!isRecording) return
+    const el = e.target as HTMLInputElement | HTMLTextAreaElement
+    if (!el || !('value' in el)) return
+
+    // Clear previous timer for this element
+    const prev = inputTimers.get(el)
+    if (prev) clearTimeout(prev)
+
+    const timer = setTimeout(() => {
+      const isSensitive = el.type === 'password' || el.getAttribute('autocomplete')?.includes('password')
+      send({
+        interactionType: 'input',
+        timestamp: Date.now(),
+        selector: getSelector(el),
+        xpath: getXPath(el),
+        tagName: el.tagName.toLowerCase(),
+        elementText: null,
+        attributes: getAttributes(el),
+        boundingRect: el.getBoundingClientRect().toJSON(),
+        inputValue: isSensitive ? '[MASKED]' : el.value,
+        url: location.href,
+        pageTitle: document.title,
+      })
+      inputTimers.delete(el)
+    }, 500)
+    inputTimers.set(el, timer)
+  }, true)
+
+  // Scroll (throttled to max once per 200ms)
+  let lastScrollTime = 0
+  let scrollTimer: ReturnType<typeof setTimeout> | null = null
+  document.addEventListener('scroll', () => {
+    if (!isRecording) return
+    const now = Date.now()
+    if (now - lastScrollTime < 200) {
+      // Queue final position
+      if (scrollTimer) clearTimeout(scrollTimer)
+      scrollTimer = setTimeout(() => {
+        emitScroll()
+        scrollTimer = null
+      }, 250)
+      return
+    }
+    lastScrollTime = now
+    emitScroll()
+  }, true)
+
+  function emitScroll(): void {
+    send({
+      interactionType: 'scroll',
+      timestamp: Date.now(),
+      scrollX: window.scrollX,
+      scrollY: window.scrollY,
+      viewportX: window.innerWidth / 2,
+      viewportY: window.innerHeight / 2,
+      url: location.href,
+      pageTitle: document.title,
+    })
+  }
+
+  // Mouse move (sampled)
+  document.addEventListener('mousemove', (e: MouseEvent) => {
+    if (!isRecording) return
+    const now = Date.now()
+
+    // Check idle threshold — flush if mouse was idle
+    if (now - lastMoveTime > IDLE_THRESHOLD && moveBuffer.length > 0) {
+      flushMoveBuffer()
+    }
+
+    // Time-based sampling
+    if (now - lastMoveTime < MOVE_SAMPLE_INTERVAL) return
+
+    // Distance filter
+    const dx = e.clientX - lastMoveX
+    const dy = e.clientY - lastMoveY
+    if (Math.sqrt(dx * dx + dy * dy) < MIN_MOVE_DISTANCE) return
+
+    lastMoveTime = now
+    lastMoveX = e.clientX
+    lastMoveY = e.clientY
+
+    moveBuffer.push({ x: e.clientX, y: e.clientY, t: now })
+
+    // Start flush timer if not already running
+    if (!moveFlushTimer) {
+      moveFlushTimer = setTimeout(() => {
+        flushMoveBuffer()
+        moveFlushTimer = null
+      }, MOVE_FLUSH_INTERVAL)
+    }
+  }, true)
+
+  function flushMoveBuffer(): void {
+    if (moveBuffer.length < 3) {
+      moveBuffer = []
+      return // ignore very short movements
+    }
+    send({
+      interactionType: 'hover',
+      timestamp: moveBuffer[0].t,
+      path: moveBuffer,
+      url: location.href,
+      pageTitle: document.title,
+    })
+    moveBuffer = []
+    if (moveFlushTimer) {
+      clearTimeout(moveFlushTimer)
+      moveFlushTimer = null
+    }
+  }
+})()