lots of fixes, lots more notes

Author: Roo Code

Cargo.lock

@@ -84,6 +84,7 @@ urlencoding = "2.1"
 dashmap = "6.1"
 heck = "0.5"
 path_abs = "0.5"
+ordered-float = "4.5.0"
 
 # Math/Linear Algebra (needed for GPU compute)
 nalgebra = "0.34.0"

Cargo.toml

@@ -11,9 +11,11 @@ export const IFRAME_COMMUNICATION_CONFIG = {
     // Add other trusted origins here
   ],
 
-  // Target origin for sending messages (use specific origin in production)
-  // Currently using '*' for development, but should be updated
-  targetOrigin: '*', // TODO: Change to 'https://narrativegoldmine.com' in production
+  // Target origin for sending messages - SECURITY FIX: Use specific origin
+  // In development, use current origin; in production, use specific domain
+  targetOrigin: process.env.NODE_ENV === 'production'
+    ? 'https://narrativegoldmine.com'
+    : window.location.origin, // Safe same-origin in development
 
   // Message action types
   messageActions: {

client/src/config/iframeCommunication.ts

@@ -219,64 +219,125 @@ export const useAnalyticsStore = create<AnalyticsState>()(
 
       computeSSSP: async (nodes, edges, sourceNodeId, algorithm = 'dijkstra') => {
         const startTime = performance.now()
-        
+
         set({ loading: true, error: null })
-        
+
         try {
           // Validate input
           if (!nodes.length || !sourceNodeId) {
             throw new Error('Invalid input: nodes array is empty or sourceNodeId is missing')
           }
-          
+
           const sourceNode = nodes.find(n => n.id === sourceNodeId)
           if (!sourceNode) {
             throw new Error(`Source node with id ${sourceNodeId} not found`)
           }
-          
+
           // Generate graph hash for caching
           const graphHash = hashGraph(nodes, edges)
-          
+
           // Check cache first
           const cachedResult = get().getCachedResult(sourceNodeId, graphHash)
           if (cachedResult) {
             const computationTime = performance.now() - startTime
             get().updateMetrics(computationTime, true)
-            
-            set({ 
-              currentResult: cachedResult, 
+
+            set({
+              currentResult: cachedResult,
               loading: false,
               lastGraphHash: graphHash
             })
-            
+
             if (debugState.isEnabled()) {
               logger.info('SSSP result retrieved from cache', { sourceNodeId, algorithm })
             }
-            
+
             return cachedResult
           }
-          
-          // Compute SSSP based on algorithm
-          let baseResult: Omit<SSSPResult, 'timestamp' | 'computationTime' | 'algorithm'>
-          
-          switch (algorithm) {
-            case 'bellman-ford':
-              baseResult = bellmanFord(nodes, edges, sourceNodeId)
-              break
-            case 'dijkstra':
-            default:
-              baseResult = dijkstra(nodes, edges, sourceNodeId)
-              break
-          }
-          
-          const computationTime = performance.now() - startTime
-          
-          const result: SSSPResult = {
-            ...baseResult,
-            algorithm,
-            computationTime,
-            timestamp: Date.now()
+
+          // Declare result variable outside try-catch
+          let result: SSSPResult
+
+          // Try server API first
+          try {
+            const response = await fetch('/api/analytics/shortest-path', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                source_node_id: parseInt(sourceNodeId), // Convert to number for server
+              }),
+            })
+
+            if (!response.ok) {
+              throw new Error(`Server error: ${response.statusText}`)
+            }
+
+            const data = await response.json()
+
+            if (!data.success) {
+              throw new Error(data.error || 'SSSP computation failed on server')
+            }
+
+            // Convert server response to our format
+            const distances: Record<string, number> = {}
+            const predecessors: Record<string, string | null> = {}
+
+            for (const [nodeId, distance] of Object.entries(data.distances || {})) {
+              distances[nodeId] = distance === null ? Infinity : distance as number
+              // Server doesn't return predecessors yet, so we set them to null
+              predecessors[nodeId] = null
+            }
+
+            const computationTime = performance.now() - startTime
+
+            result = {
+              sourceNodeId,
+              distances,
+              predecessors,
+              unreachableCount: data.unreachable_count || 0,
+              algorithm,
+              computationTime,
+              timestamp: Date.now()
+            }
+
+            if (debugState.isEnabled()) {
+              logger.info('SSSP computed on server', {
+                sourceNodeId,
+                algorithm,
+                unreachableCount: result.unreachableCount,
+                computationTime
+              })
+            }
+
+          } catch (apiError) {
+            // If server fails, fall back to local computation
+            logger.warn('Server SSSP failed, falling back to local computation', apiError)
+
+            // Compute SSSP locally as fallback
+            let baseResult: Omit<SSSPResult, 'timestamp' | 'computationTime' | 'algorithm'>
+
+            switch (algorithm) {
+              case 'bellman-ford':
+                baseResult = bellmanFord(nodes, edges, sourceNodeId)
+                break
+              case 'dijkstra':
+              default:
+                baseResult = dijkstra(nodes, edges, sourceNodeId)
+                break
+            }
+
+            const computationTime = performance.now() - startTime
+
+            result = {
+              ...baseResult,
+              algorithm,
+              computationTime,
+              timestamp: Date.now()
+            }
           }
-          
+
           // Update state with result and cache
           set(state => produce(state, draft => {
             draft.currentResult = result

client/src/features/analytics/store/analyticsStore.ts

@@ -14,19 +14,24 @@ export interface BinaryNodeData {
   nodeId: number;
   position: Vec3;
   velocity: Vec3;
+  // SSSP data removed - now fetched via REST API when needed
+  // This reduces binary message size from 34 to 26 bytes per node
 }
 
 /**
- * Node binary format (WireNodeDataItem):
- * - Node ID: 2 bytes (uint16) - includes type flags in high bits
+ * Node binary format (Optimized):
+ * - Node ID: 4 bytes (uint32) - full node ID without flags
  * - Position: 12 bytes (3 float32 values)
  * - Velocity: 12 bytes (3 float32 values)
- * Total: 26 bytes per node
+ * Total: 28 bytes per node (reduced from 34)
+ *
+ * SSSP and other analytics data are fetched via REST API when needed
  */
-export const BINARY_NODE_SIZE = 26;
+export const BINARY_NODE_SIZE = 28;
 export const BINARY_NODE_ID_OFFSET = 0;
-export const BINARY_POSITION_OFFSET = 2;
-export const BINARY_VELOCITY_OFFSET = 14;
+export const BINARY_POSITION_OFFSET = 4;
+export const BINARY_VELOCITY_OFFSET = 16;
+// SSSP offsets removed - data no longer in binary protocol
 
 // Node type flag constants (must match server) - adjusted for u16
 export const AGENT_NODE_FLAG = 0x8000;     // Bit 15 indicates agent node
@@ -102,10 +107,9 @@ export function parseBinaryNodeData(buffer: ArrayBuffer): BinaryNodeData[] {
         break;
       }
 
-      // Read node ID (uint16, 2 bytes) - includes type flags
-      const rawNodeId = view.getUint16(offset + BINARY_NODE_ID_OFFSET, true);
-      const nodeId = getActualNodeId(rawNodeId);  // Extract actual ID without flags
-      
+      // Read node ID (uint32, 4 bytes) - no flags needed anymore
+      const nodeId = view.getUint32(offset + BINARY_NODE_ID_OFFSET, true);
+
       // Read position (3 float32 values, 12 bytes)
       const position: Vec3 = {
         x: view.getFloat32(offset + BINARY_POSITION_OFFSET, true),
@@ -120,15 +124,17 @@ export function parseBinaryNodeData(buffer: ArrayBuffer): BinaryNodeData[] {
         z: view.getFloat32(offset + BINARY_VELOCITY_OFFSET + 8, true)
       };
 
+      // SSSP data removed - fetched via REST API when needed
+
       // Basic validation to detect corrupted data
-      const isValid = 
+      const isValid =
         !isNaN(position.x) && isFinite(position.x) &&
         !isNaN(position.y) && isFinite(position.y) &&
         !isNaN(position.z) && isFinite(position.z) &&
         !isNaN(velocity.x) && isFinite(velocity.x) &&
         !isNaN(velocity.y) && isFinite(velocity.y) &&
         !isNaN(velocity.z) && isFinite(velocity.z);
-      
+
       if (isValid) {
         nodes.push({ nodeId, position, velocity });
       } else {
@@ -165,6 +171,12 @@ export function createBinaryNodeData(nodes: BinaryNodeData[]): ArrayBuffer {
     view.setFloat32(offset + BINARY_VELOCITY_OFFSET, node.velocity.x, true);
     view.setFloat32(offset + BINARY_VELOCITY_OFFSET + 4, node.velocity.y, true);
     view.setFloat32(offset + BINARY_VELOCITY_OFFSET + 8, node.velocity.z, true);
+
+    // Write SSSP distance (float32, 4 bytes)
+    view.setFloat32(offset + BINARY_SSSP_DISTANCE_OFFSET, node.ssspDistance || Infinity, true);
+
+    // Write SSSP parent (int32, 4 bytes)
+    view.setInt32(offset + BINARY_SSSP_PARENT_OFFSET, node.ssspParent || -1, true);
   });
 
   return buffer;