@veraxhq/verax 0.2.1 → 0.3.0

package/src/verax/observe/observers/safety-observer.js

@@ -0,0 +1,82 @@
+/**
+ * PHASE 21.3 — Safety Observer
+ * 
+ * Responsibilities:
+ * - Network interception (cross-origin blocking, write method blocking)
+ * - NO file I/O
+ * - NO side effects outside its scope
+ */
+
+/**
+ * Setup network interception firewall
+ * 
+ * @param {ObserveContext} context - Observe context
+ * @returns {Promise<void>}
+ */
+export async function setupNetworkInterception(context) {
+  const { page, baseOrigin, safetyFlags, silenceTracker, blockedNetworkWrites, blockedCrossOrigin } = context;
+  const { allowWrites = false, allowCrossOrigin = false } = safetyFlags;
+
+  await page.route('**/*', (route) => {
+    const request = route.request();
+    const method = request.method();
+    const requestUrl = request.url();
+    const resourceType = request.resourceType();
+    
+    // Check cross-origin blocking (skip for file:// URLs)
+    if (!allowCrossOrigin && !requestUrl.startsWith('file://')) {
+      try {
+        const reqOrigin = new URL(requestUrl).origin;
+        if (reqOrigin !== baseOrigin) {
+          blockedCrossOrigin.push({
+            url: requestUrl,
+            origin: reqOrigin,
+            method,
+            resourceType,
+            timestamp: Date.now()
+          });
+          
+          silenceTracker.record({
+            scope: 'safety',
+            reason: 'cross_origin_blocked',
+            description: `Cross-origin request blocked: ${method} ${requestUrl}`,
+            context: { url: requestUrl, origin: reqOrigin, method, baseOrigin },
+            impact: 'request_blocked'
+          });
+          
+          return route.abort('blockedbyclient');
+        }
+      } catch (e) {
+        // Invalid URL, allow and let browser handle
+      }
+    }
+    
+    // Check write method blocking
+    if (!allowWrites && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+      // Check if it's a GraphQL mutation (best-effort)
+      const isGraphQLMutation = requestUrl.includes('/graphql') && method === 'POST';
+      
+      blockedNetworkWrites.push({
+        url: requestUrl,
+        method,
+        resourceType,
+        isGraphQLMutation,
+        timestamp: Date.now()
+      });
+      
+      silenceTracker.record({
+        scope: 'safety',
+        reason: 'blocked_network_write',
+        description: `Network write blocked: ${method} ${requestUrl}${isGraphQLMutation ? ' (GraphQL mutation)' : ''}`,
+        context: { url: requestUrl, method, resourceType, isGraphQLMutation },
+        impact: 'write_blocked'
+      });
+      
+      return route.abort('blockedbyclient');
+    }
+    
+    // Allow request
+    route.continue();
+  });
+}
+

package/src/verax/observe/observers/ui-feedback-observer.js

@@ -0,0 +1,99 @@
+/**
+ * PHASE 21.3 — UI Feedback Observer
+ * 
+ * Responsibilities:
+ * - DOM mutation observation
+ * - Loading / disabled / feedback signals
+ * - UI settle signals (NO adaptive waiting - that's in settle.js)
+ * 
+ * NO file I/O
+ * NO side effects outside its scope
+ */
+
+import { UISignalSensor } from '../ui-signal-sensor.js';
+import { captureDomSignature } from '../dom-signature.js';
+
+/**
+ * Observe UI feedback and DOM state on current page
+ * 
+ * @param {ObserveContext} context - Observe context
+ * @param {RunState} runState - Current run state
+ * @returns {Promise<Array<Observation>>} Array of UI feedback observations
+ */
+export async function observe(context, runState) {
+  const { page, currentUrl, timestamp } = context;
+  const observations = [];
+  
+  try {
+    // Capture current UI signals
+    const uiSignalSensor = new UISignalSensor();
+    const uiSignals = await uiSignalSensor.snapshot(page);
+    
+    // Capture DOM signature for mutation tracking
+    const domSignature = await captureDomSignature(page);
+    
+    // Create observation for UI signals
+    observations.push({
+      type: 'ui_feedback',
+      scope: 'page',
+      data: {
+        hasLoadingIndicator: uiSignals.hasLoadingIndicator,
+        hasDialog: uiSignals.hasDialog,
+        hasErrorSignal: uiSignals.hasErrorSignal,
+        hasStatusSignal: uiSignals.hasStatusSignal,
+        hasLiveRegion: uiSignals.hasLiveRegion,
+        validationFeedbackDetected: uiSignals.validationFeedbackDetected,
+        disabledElementsCount: uiSignals.disabledElements?.length || 0,
+        explanation: uiSignals.explanation || []
+      },
+      timestamp,
+      url: currentUrl
+    });
+    
+    // Create observation for DOM state
+    observations.push({
+      type: 'dom_state',
+      scope: 'page',
+      data: {
+        domHash: domSignature,
+        hasDom: !!domSignature
+      },
+      timestamp,
+      url: currentUrl
+    });
+    
+    // If there are loading indicators, create specific observation
+    if (uiSignals.hasLoadingIndicator) {
+      observations.push({
+        type: 'ui_loading',
+        scope: 'page',
+        data: {
+          loading: true,
+          explanation: uiSignals.explanation?.filter(e => e.includes('loading') || e.includes('busy')) || []
+        },
+        timestamp,
+        url: currentUrl
+      });
+    }
+    
+    // If there are disabled elements, create observation
+    if (uiSignals.disabledElements && uiSignals.disabledElements.length > 0) {
+      observations.push({
+        type: 'ui_disabled',
+        scope: 'page',
+        data: {
+          disabledCount: uiSignals.disabledElements.length,
+          disabledElements: uiSignals.disabledElements.slice(0, 10) // Limit to 10
+        },
+        timestamp,
+        url: currentUrl
+      });
+    }
+  } catch (error) {
+    // Propagate error - no silent catch
+    throw new Error(`UI feedback observer failed: ${error.message}`);
+  }
+  
+  return observations;
+}
+