@mseep/anything-analyzer 3.6.50

package/src/main/capture/capture-engine.ts

@@ -0,0 +1,130 @@
+import { EventEmitter } from 'events'
+import type { WebContents } from 'electron'
+import type { CapturedRequest, JsHookRecord, StorageSnapshot } from '@shared/types'
+import type { RequestsRepo, JsHooksRepo, StorageSnapshotsRepo } from '../db/repositories'
+
+/**
+ * CaptureEngine — Aggregates data from CDP, JS hooks, and storage collectors,
+ * writes structured data to SQLite, and emits IPC events to the renderer.
+ */
+export class CaptureEngine extends EventEmitter {
+  private sessionId: string | null = null
+  private rendererWebContents: WebContents | null = null
+
+  constructor(
+    private requestsRepo: RequestsRepo,
+    private jsHooksRepo: JsHooksRepo,
+    private storageSnapshotsRepo: StorageSnapshotsRepo
+  ) {
+    super()
+  }
+
+  start(sessionId: string, rendererWebContents: WebContents): void {
+    this.sessionId = sessionId
+    this.rendererWebContents = rendererWebContents
+  }
+
+  stop(): void {
+    this.sessionId = null
+    this.rendererWebContents = null
+  }
+
+  handleResponseCaptured(data: {
+    requestId: string; method: string; url: string;
+    requestHeaders: string; requestBody: string | null;
+    statusCode: number; responseHeaders: string;
+    responseBody: string | null; contentType: string | null;
+    initiator: string | null; durationMs: number | null;
+    isOptions: boolean; isStatic: boolean; isStreaming: boolean; isWebSocket: boolean; truncated: boolean; timestamp: number;
+    source?: 'cdp' | 'proxy'
+  }): void {
+    if (!this.sessionId) return
+
+    let sequence: number
+    // Guard quit race: DB may already be closing during app shutdown.
+    try {
+      sequence = this.requestsRepo.getNextSequence(this.sessionId)
+    } catch (err) {
+      console.warn('[CaptureEngine] getNextSequence failed:', (err as Error).message)
+      return
+    }
+
+    // Generate a unique ID per record to avoid UNIQUE constraint conflicts.
+    // The original requestId from CDP/proxy may repeat across sessions or retries.
+    const uniqueId = `${this.sessionId}-${sequence}`
+
+    try {
+      this.requestsRepo.insert({
+        id: uniqueId, session_id: this.sessionId, sequence,
+        timestamp: data.timestamp, method: data.method, url: data.url,
+        request_headers: data.requestHeaders, request_body: data.requestBody,
+        content_type: data.contentType, initiator: data.initiator,
+        source: data.source || 'cdp'
+      })
+    } catch (err) {
+      console.warn('[CaptureEngine] Insert failed:', (err as Error).message)
+    }
+
+    try {
+      this.requestsRepo.updateResponse({
+        id: uniqueId, status_code: data.statusCode,
+        response_headers: data.responseHeaders,
+        response_body: data.responseBody,
+        content_type: data.contentType, duration_ms: data.durationMs || 0,
+        is_streaming: data.isStreaming ? 1 : 0,
+        is_websocket: data.isWebSocket ? 1 : 0
+      })
+    } catch { /* ignore */ }
+
+    const captured: CapturedRequest = {
+      id: uniqueId, session_id: this.sessionId, sequence,
+      timestamp: data.timestamp, method: data.method, url: data.url,
+      request_headers: data.requestHeaders, request_body: data.requestBody,
+      status_code: data.statusCode, response_headers: data.responseHeaders,
+      response_body: data.responseBody, content_type: data.contentType,
+      initiator: data.initiator, duration_ms: data.durationMs,
+      is_streaming: data.isStreaming, is_websocket: data.isWebSocket,
+      source: data.source || 'cdp'
+    }
+    this.sendToRenderer('capture:request', captured)
+  }
+
+  handleHookCaptured(data: {
+    hookType: string; functionName: string; arguments: string;
+    result: string | null; callStack: string | null; timestamp: number
+  }): void {
+    if (!this.sessionId) return
+
+    const record: Omit<JsHookRecord, 'id'> = {
+      session_id: this.sessionId, timestamp: data.timestamp,
+      hook_type: data.hookType as JsHookRecord['hook_type'],
+      function_name: data.functionName, arguments: data.arguments,
+      result: data.result, call_stack: data.callStack, related_request_id: null
+    }
+
+    try { this.jsHooksRepo.insert(record) } catch { /* ignore */ }
+    this.sendToRenderer('capture:hook', record)
+  }
+
+  handleStorageCollected(data: {
+    domain: string; storageType: string; data: string; timestamp: number
+  }): void {
+    if (!this.sessionId) return
+
+    const snapshot: Omit<StorageSnapshot, 'id'> = {
+      session_id: this.sessionId, timestamp: data.timestamp,
+      domain: data.domain,
+      storage_type: data.storageType as StorageSnapshot['storage_type'],
+      data: data.data
+    }
+
+    try { this.storageSnapshotsRepo.insert(snapshot) } catch { /* ignore */ }
+    this.sendToRenderer('capture:storage', snapshot)
+  }
+
+  private sendToRenderer(channel: string, data: unknown): void {
+    if (this.rendererWebContents && !this.rendererWebContents.isDestroyed()) {
+      this.rendererWebContents.send(channel, data)
+    }
+  }
+}

package/src/main/capture/interaction-recorder.ts

@@ -0,0 +1,171 @@
+import { EventEmitter } from 'events'
+import type { WebContents } from 'electron'
+import type { InteractionEventsRepo } from '../db/repositories'
+import type { InteractionEvent, RawInteractionData } from '@shared/types'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+/**
+ * InteractionRecorder — Records user interactions (clicks, inputs, scrolls, mouse movements)
+ * from the target browser and persists them to SQLite.
+ */
+export class InteractionRecorder extends EventEmitter {
+  private sessionId: string | null = null
+  private rendererWebContents: WebContents | null = null
+  private recording = false
+  private scriptContent: string | null = null
+  private injectedWebContents: Set<WebContents> = new Set()
+
+  constructor(private repo: InteractionEventsRepo) {
+    super()
+  }
+
+  /** Start recording interactions (injection is handled separately via injectIntoWebContents) */
+  start(sessionId: string, rendererWebContents: WebContents): void {
+    this.sessionId = sessionId
+    this.rendererWebContents = rendererWebContents
+    this.recording = true
+    this.loadScript()
+  }
+
+  /**
+   * Inject interaction-hook script into a WebContents (for multi-tab support).
+   * Called by SessionManager when tabs are attached to the capture pipeline.
+   */
+  injectIntoWebContents(webContents: WebContents): void {
+    this.loadScript()
+    if (!this.scriptContent) return
+    if (webContents.isDestroyed()) return
+    webContents.executeJavaScript(this.scriptContent, true).catch(() => { /* page not ready or destroyed */ })
+
+    this.injectedWebContents.add(webContents)
+    webContents.once('destroyed', () => {
+      this.injectedWebContents.delete(webContents)
+    })
+
+    // Set recording state
+    if (this.recording) {
+      webContents.executeJavaScript(
+        `window.postMessage({type:'ar-interaction-control',recording:true},'*')`,
+        true
+      ).catch(() => {})
+    }
+
+    // Re-inject on navigation for this tab
+    const handler = () => {
+      if (!this.recording || webContents.isDestroyed()) return
+      webContents.executeJavaScript(this.scriptContent!, true).catch(() => {})
+      webContents.executeJavaScript(
+        `window.postMessage({type:'ar-interaction-control',recording:true},'*')`,
+        true
+      ).catch(() => {})
+    }
+    webContents.on('did-navigate', handler)
+    webContents.on('did-navigate-in-page', handler)
+  }
+
+  /** Pause recording (keeps session active) */
+  pause(): void {
+    this.recording = false
+    this.setRecordingState(false)
+  }
+
+  /** Resume recording */
+  resume(): void {
+    this.recording = true
+    this.setRecordingState(true)
+  }
+
+  /** Stop recording and clean up */
+  stop(): void {
+    this.recording = false
+    this.sessionId = null
+    this.rendererWebContents = null
+    this.injectedWebContents.clear()
+  }
+
+  /** Process interaction data from page injection script */
+  handleInteraction(data: RawInteractionData): void {
+    if (!this.recording || !this.sessionId) return
+
+    let sequence: number
+    try {
+      sequence = this.repo.getNextSequence(this.sessionId)
+    } catch (err) {
+      console.warn('[InteractionRecorder] getNextSequence failed:', (err as Error).message)
+      return
+    }
+
+    const event: Omit<InteractionEvent, 'id'> = {
+      session_id: this.sessionId,
+      sequence,
+      type: data.type,
+      timestamp: data.timestamp,
+      x: data.x ?? null,
+      y: data.y ?? null,
+      viewport_x: data.viewportX ?? null,
+      viewport_y: data.viewportY ?? null,
+      selector: data.selector ?? null,
+      xpath: data.xpath ?? null,
+      tag_name: data.tagName ?? null,
+      element_text: data.elementText ?? null,
+      attributes: data.attributes ? JSON.stringify(data.attributes) : null,
+      bounding_rect: data.boundingRect ? JSON.stringify(data.boundingRect) : null,
+      input_value: data.inputValue ?? null,
+      key: data.key ?? null,
+      scroll_x: data.scrollX ?? null,
+      scroll_y: data.scrollY ?? null,
+      scroll_dx: data.scrollDX ?? null,
+      scroll_dy: data.scrollDY ?? null,
+      url: data.url,
+      page_title: data.pageTitle ?? null,
+      path: data.path ? JSON.stringify(data.path) : null,
+      created_at: Date.now(),
+    }
+
+    try {
+      this.repo.insert(event)
+    } catch (err) {
+      console.warn('[InteractionRecorder] Insert failed:', (err as Error).message)
+      return
+    }
+
+    // Notify renderer (lightweight event, no heavy data)
+    if (this.rendererWebContents && !this.rendererWebContents.isDestroyed()) {
+      this.rendererWebContents.send('interaction:recorded', {
+        type: data.type,
+        sequence,
+        timestamp: data.timestamp,
+      })
+    }
+    this.emit('interaction', event)
+  }
+
+  isRecording(): boolean {
+    return this.recording
+  }
+
+  getSessionId(): string | null {
+    return this.sessionId
+  }
+
+  private loadScript(): void {
+    if (this.scriptContent) return
+    try {
+      const scriptPath = join(__dirname, '../preload/interaction-hook.js')
+      this.scriptContent = readFileSync(scriptPath, 'utf-8')
+    } catch {
+      this.scriptContent = `console.log('[AnythingAnalyzer] Interaction hook script not found')`
+    }
+  }
+
+  private setRecordingState(recording: boolean): void {
+    for (const wc of this.injectedWebContents) {
+      if (wc.isDestroyed()) continue
+      wc.executeJavaScript(
+        `window.postMessage({type:'ar-interaction-control',recording:${recording}},'*')`,
+        true
+      ).catch(() => {})
+    }
+  }
+}

package/src/main/capture/js-injector.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from "events";
+import type { WebContents } from "electron";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * JsInjector — Manages hook script injection into a target browser WebContents.
+ * Only handles script injection and re-injection on navigation.
+ * IPC hook data listening is handled externally (SessionManager).
+ */
+export class JsInjector extends EventEmitter {
+  private webContents: WebContents | null = null;
+  private hookScriptContent: string | null = null;
+  private navigationHandler: (() => void) | null = null;
+
+  start(webContents: WebContents): void {
+    this.webContents = webContents;
+    this.loadHookScript();
+    this.injectHooks();
+
+    this.navigationHandler = () => {
+      this.injectHooks();
+    };
+    webContents.on("did-navigate", this.navigationHandler);
+    webContents.on("did-navigate-in-page", this.navigationHandler);
+  }
+
+  stop(): void {
+    if (this.webContents && this.navigationHandler) {
+      this.webContents.removeListener("did-navigate", this.navigationHandler);
+      this.webContents.removeListener(
+        "did-navigate-in-page",
+        this.navigationHandler,
+      );
+    }
+    this.webContents = null;
+    this.navigationHandler = null;
+  }
+
+  private loadHookScript(): void {
+    if (this.hookScriptContent) return;
+    try {
+      const scriptPath = join(__dirname, "../preload/hook-script.js");
+      this.hookScriptContent = readFileSync(scriptPath, "utf-8");
+    } catch {
+      this.hookScriptContent = `console.log('[AnythingAnalyzer] Hook script not found')`;
+    }
+  }
+
+  private injectHooks(): void {
+    if (!this.webContents || !this.hookScriptContent) return;
+    if (this.webContents.isDestroyed()) return;
+    this.webContents.executeJavaScript(this.hookScriptContent, true).catch(() => {
+      /* not ready or destroyed */
+    });
+  }
+}

package/src/main/capture/replay-engine.ts

@@ -0,0 +1,256 @@
+import type { WebContents } from 'electron'
+import type { InteractionEvent } from '@shared/types'
+
+interface ReplayOptions {
+  speed: number       // Playback speed multiplier (1.0 = original)
+  skipMoves: boolean  // Whether to skip hover/move events
+}
+
+/**
+ * ReplayEngine — Replays recorded interaction events via CDP Input domain.
+ */
+export class ReplayEngine {
+  private aborted = false
+
+  /** Send a CDP command, checking for destroyed WebContents first. */
+  private async cdp(
+    wc: WebContents,
+    method: string,
+    params: Record<string, unknown> = {}
+  ): Promise<Record<string, unknown>> {
+    if (wc.isDestroyed()) throw new Error('WebContents destroyed during replay')
+    return wc.debugger.sendCommand(method, params) as Promise<Record<string, unknown>>
+  }
+
+  /** Safely load a URL, checking for destroyed WebContents first. */
+  private async safeLoadURL(wc: WebContents, url: string): Promise<void> {
+    if (wc.isDestroyed()) throw new Error('WebContents destroyed during replay')
+    await wc.loadURL(url)
+  }
+
+  async replay(
+    webContents: WebContents,
+    events: InteractionEvent[],
+    options: ReplayOptions = { speed: 1, skipMoves: false }
+  ): Promise<{ success: boolean; stepsCompleted: number; error?: string }> {
+    this.aborted = false
+    let completed = 0
+
+    if (webContents.isDestroyed()) {
+      return { success: false, stepsCompleted: 0, error: 'WebContents destroyed' }
+    }
+
+    if (!webContents.debugger.isAttached()) {
+      try {
+        webContents.debugger.attach('1.3')
+      } catch (err) {
+        return { success: false, stepsCompleted: 0, error: `Failed to attach debugger: ${(err as Error).message}` }
+      }
+    }
+
+    try {
+      for (let i = 0; i < events.length; i++) {
+        if (this.aborted || webContents.isDestroyed()) break
+        const event = events[i]
+
+        if (options.skipMoves && event.type === 'hover') {
+          continue
+        }
+
+        await this.executeStep(webContents, event)
+        completed++
+
+        // Wait between events based on original timing
+        const nextEvent = events[i + 1]
+        if (nextEvent) {
+          const delay = (nextEvent.timestamp - event.timestamp) / options.speed
+          await this.wait(Math.min(Math.max(delay, 10), 3000))
+        }
+      }
+    } catch (err) {
+      return { success: false, stepsCompleted: completed, error: (err as Error).message }
+    }
+
+    return { success: !this.aborted, stepsCompleted: completed }
+  }
+
+  abort(): void {
+    this.aborted = true
+  }
+
+  /** Execute a single browser action (for MCP execute_browser_action tool) */
+  async executeAction(
+    webContents: WebContents,
+    action: { type: string; selector?: string; text?: string; url?: string; x?: number; y?: number; scrollDelta?: number }
+  ): Promise<{ success: boolean; error?: string }> {
+    if (webContents.isDestroyed()) {
+      return { success: false, error: 'WebContents destroyed' }
+    }
+
+    if (!webContents.debugger.isAttached()) {
+      try {
+        webContents.debugger.attach('1.3')
+      } catch (err) {
+        return { success: false, error: `Failed to attach debugger: ${(err as Error).message}` }
+      }
+    }
+
+    try {
+      switch (action.type) {
+        case 'click': {
+          if (action.selector) {
+            const coords = await this.resolveElementCenter(webContents, action.selector)
+            if (!coords) return { success: false, error: `Element not found: ${action.selector}` }
+            await this.clickAt(webContents, coords.x, coords.y)
+          } else if (action.x != null && action.y != null) {
+            await this.clickAt(webContents, action.x, action.y)
+          } else {
+            return { success: false, error: 'click requires selector or x/y coordinates' }
+          }
+          break
+        }
+        case 'type': {
+          if (!action.text) return { success: false, error: 'type requires text' }
+          if (action.selector) {
+            await this.cdp(webContents, 'Runtime.evaluate', {
+              expression: `document.querySelector(${JSON.stringify(action.selector)})?.focus()`
+            })
+            await this.wait(50)
+          }
+          for (const char of action.text) {
+            await this.cdp(webContents, 'Input.dispatchKeyEvent', {
+              type: 'char', text: char
+            })
+            await this.wait(20)
+          }
+          break
+        }
+        case 'scroll': {
+          const x = action.x ?? 400
+          const y = action.y ?? 300
+          const delta = action.scrollDelta ?? 200
+          await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+            type: 'mouseWheel', x, y, deltaX: 0, deltaY: delta
+          })
+          break
+        }
+        case 'navigate': {
+          if (!action.url) return { success: false, error: 'navigate requires url' }
+          await this.safeLoadURL(webContents, action.url)
+          break
+        }
+        default:
+          return { success: false, error: `Unknown action type: ${action.type}` }
+      }
+      return { success: true }
+    } catch (err) {
+      return { success: false, error: (err as Error).message }
+    }
+  }
+
+  private async executeStep(webContents: WebContents, event: InteractionEvent): Promise<void> {
+    switch (event.type) {
+      case 'click':
+      case 'dblclick': {
+        const x = event.viewport_x ?? event.x ?? 0
+        const y = event.viewport_y ?? event.y ?? 0
+        const clickCount = event.type === 'dblclick' ? 2 : 1
+        await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+          type: 'mouseMoved', x, y
+        })
+        await this.wait(30)
+        await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+          type: 'mousePressed', x, y, button: 'left', clickCount
+        })
+        await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+          type: 'mouseReleased', x, y, button: 'left', clickCount
+        })
+        break
+      }
+      case 'input': {
+        if (event.selector && event.input_value != null) {
+          await this.cdp(webContents, 'Runtime.evaluate', {
+            expression: `document.querySelector(${JSON.stringify(event.selector)})?.focus()`
+          })
+          await this.wait(50)
+          await this.cdp(webContents, 'Runtime.evaluate', {
+            expression: `{
+              const el = document.querySelector(${JSON.stringify(event.selector)});
+              if (el) { el.value = ''; el.dispatchEvent(new Event('input', {bubbles:true})); }
+            }`
+          })
+          for (const char of event.input_value) {
+            await this.cdp(webContents, 'Input.dispatchKeyEvent', {
+              type: 'char', text: char
+            })
+            await this.wait(15)
+          }
+        }
+        break
+      }
+      case 'scroll': {
+        await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+          type: 'mouseWheel',
+          x: event.viewport_x ?? 400,
+          y: event.viewport_y ?? 300,
+          deltaX: event.scroll_dx ?? 0,
+          deltaY: event.scroll_dy ?? 0
+        })
+        break
+      }
+      case 'navigate': {
+        if (event.url) {
+          await this.safeLoadURL(webContents, event.url)
+          await this.wait(500)
+        }
+        break
+      }
+      case 'hover': {
+        if (event.path) {
+          const points = JSON.parse(event.path) as Array<{ x: number; y: number; t: number }>
+          for (const point of points) {
+            if (this.aborted) break
+            await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+              type: 'mouseMoved', x: point.x, y: point.y
+            })
+            await this.wait(20)
+          }
+        }
+        break
+      }
+    }
+  }
+
+  private async clickAt(webContents: WebContents, x: number, y: number): Promise<void> {
+    await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+      type: 'mouseMoved', x, y
+    })
+    await this.wait(30)
+    await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+      type: 'mousePressed', x, y, button: 'left', clickCount: 1
+    })
+    await this.cdp(webContents, 'Input.dispatchMouseEvent', {
+      type: 'mouseReleased', x, y, button: 'left', clickCount: 1
+    })
+  }
+
+  private async resolveElementCenter(
+    webContents: WebContents,
+    selector: string
+  ): Promise<{ x: number; y: number } | null> {
+    const result = await this.cdp(webContents, 'Runtime.evaluate', {
+      expression: `(function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        const r = el.getBoundingClientRect();
+        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+      })()`,
+      returnByValue: true
+    }) as { result?: { value?: { x: number; y: number } | null } }
+    return result?.result?.value ?? null
+  }
+
+  private wait(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, Math.max(ms, 5)))
+  }
+}

package/src/main/capture/storage-collector.ts

@@ -0,0 +1,76 @@
+import { EventEmitter } from 'events'
+import type { WebContents } from 'electron'
+
+const COLLECTION_INTERVAL = 5000 // 5 seconds
+
+/**
+ * StorageCollector — Periodically collects Cookie, localStorage, and sessionStorage
+ * snapshots from the target browser via CDP commands.
+ */
+export class StorageCollector extends EventEmitter {
+  private webContents: WebContents | null = null
+  private sessionId: string | null = null
+  private timer: ReturnType<typeof setInterval> | null = null
+  private collecting = false
+
+  start(sessionId: string, webContents: WebContents): void {
+    this.sessionId = sessionId
+    this.webContents = webContents
+    this.collectAll()
+    this.timer = setInterval(() => { this.collectAll() }, COLLECTION_INTERVAL)
+  }
+
+  stop(): void {
+    if (this.timer) { clearInterval(this.timer); this.timer = null }
+    if (this.webContents && !this.webContents.isDestroyed()) this.collectAll()
+    this.webContents = null
+    this.sessionId = null
+  }
+
+  triggerCollection(): void { this.collectAll() }
+
+  private async collectAll(): Promise<void> {
+    if (this.collecting || !this.webContents || !this.sessionId) return
+    if (this.webContents.isDestroyed()) return
+    this.collecting = true
+    const domain = this.getCurrentDomain()
+    const timestamp = Date.now()
+    try {
+      await Promise.allSettled([
+        this.collectCookies(domain, timestamp),
+        this.collectLocalStorage(domain, timestamp),
+        this.collectSessionStorage(domain, timestamp)
+      ])
+    } finally { this.collecting = false }
+  }
+
+  private async collectCookies(domain: string, timestamp: number): Promise<void> {
+    if (!this.webContents || this.webContents.isDestroyed()) return
+    try {
+      const currentUrl = this.webContents.getURL()
+      const result = await this.webContents.debugger.sendCommand('Network.getCookies', { urls: [currentUrl] }) as { cookies: Array<Record<string, unknown>> }
+      this.emit('storage-collected', { domain, storageType: 'cookie', data: JSON.stringify(result.cookies || []), timestamp })
+    } catch (err) { console.warn('[StorageCollector] collectCookies failed:', (err as Error).message) }
+  }
+
+  private async collectLocalStorage(domain: string, timestamp: number): Promise<void> {
+    if (!this.webContents || this.webContents.isDestroyed()) return
+    try {
+      const result = await this.webContents.debugger.sendCommand('Runtime.evaluate', { expression: 'JSON.stringify(localStorage)', returnByValue: true }) as { result: { value?: string } }
+      this.emit('storage-collected', { domain, storageType: 'localStorage', data: result.result?.value || '{}', timestamp })
+    } catch (err) { console.warn('[StorageCollector] collectLocalStorage failed:', (err as Error).message) }
+  }
+
+  private async collectSessionStorage(domain: string, timestamp: number): Promise<void> {
+    if (!this.webContents || this.webContents.isDestroyed()) return
+    try {
+      const result = await this.webContents.debugger.sendCommand('Runtime.evaluate', { expression: 'JSON.stringify(sessionStorage)', returnByValue: true }) as { result: { value?: string } }
+      this.emit('storage-collected', { domain, storageType: 'sessionStorage', data: result.result?.value || '{}', timestamp })
+    } catch (err) { console.warn('[StorageCollector] collectSessionStorage failed:', (err as Error).message) }
+  }
+
+  private getCurrentDomain(): string {
+    if (!this.webContents || this.webContents.isDestroyed()) return 'unknown'
+    try { return new URL(this.webContents.getURL()).hostname } catch { return 'unknown' }
+  }
+}