almostnode 0.2.7 → 0.2.8

package/README.md

@@ -856,7 +856,7 @@ triggerHMR('/app/page.tsx', iframe);
 ### Setup
 
 ```bash
-git clone https://github.com/Macaly/almostnode.git
+git clone https://github.com/macaly/almostnode.git
 cd almostnode
 npm install
 ```

package/dist/__sw__.js

@@ -1,9 +1,11 @@
 /**
  * Service Worker for Mini WebContainers
  * Intercepts fetch requests and routes them to virtual servers
- * Version: 14 - forward ALL requests from virtual context (images, scripts, navigation) to virtual server
+ * Version: 15 - cleanup: extract helpers, gate debug logs, remove test endpoints
  */
 
+const DEBUG = false;
+
 // Communication port with main thread
 let mainPort = null;
 
@@ -14,30 +16,45 @@ let requestId = 0;
 // Registered virtual server ports
 const registeredPorts = new Set();
 
+/**
+ * Decode base64 string to Uint8Array
+ */
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 /**
  * Handle messages from main thread
  */
 self.addEventListener('message', (event) => {
   const { type, data } = event.data;
 
-  console.log('[SW] Received message:', type, 'hasPort in event.ports:', event.ports?.length > 0);
+  DEBUG && console.log('[SW] Received message:', type, 'hasPort in event.ports:', event.ports?.length > 0);
 
   // When a MessagePort is transferred, it's in event.ports[0], not event.data.port
   if (type === 'init' && event.ports && event.ports[0]) {
     // Initialize communication channel
     mainPort = event.ports[0];
     mainPort.onmessage = handleMainMessage;
-    console.log('[SW] Initialized communication channel with transferred port');
+    DEBUG && console.log('[SW] Initialized communication channel with transferred port');
+    // Re-claim clients so that pages opened after SW activation get controlled.
+    // Without this, controllerchange never fires for late-arriving pages.
+    self.clients.claim();
   }
 
   if (type === 'server-registered' && data) {
     registeredPorts.add(data.port);
-    console.log(`[SW] Server registered on port ${data.port}`);
+    DEBUG && console.log(`[SW] Server registered on port ${data.port}`);
   }
 
   if (type === 'server-unregistered' && data) {
     registeredPorts.delete(data.port);
-    console.log(`[SW] Server unregistered from port ${data.port}`);
+    DEBUG && console.log(`[SW] Server unregistered from port ${data.port}`);
   }
 });
 
@@ -47,20 +64,20 @@ self.addEventListener('message', (event) => {
 function handleMainMessage(event) {
   const { type, id, data, error } = event.data;
 
-  console.log('[SW] Received message from main:', type, 'id:', id);
+  DEBUG && console.log('[SW] Received message from main:', type, 'id:', id);
 
   if (type === 'response') {
     const pending = pendingRequests.get(id);
-    console.log('[SW] Looking for pending request:', id, 'found:', !!pending);
+    DEBUG && console.log('[SW] Looking for pending request:', id, 'found:', !!pending);
 
     if (pending) {
       pendingRequests.delete(id);
 
       if (error) {
-        console.log('[SW] Response error:', error);
+        DEBUG && console.log('[SW] Response error:', error);
         pending.reject(new Error(error));
       } else {
-        console.log('[SW] Response data:', {
+        DEBUG && console.log('[SW] Response data:', {
           statusCode: data?.statusCode,
           statusMessage: data?.statusMessage,
           headers: data?.headers,
@@ -74,50 +91,46 @@ function handleMainMessage(event) {
 
   // Handle streaming responses
   if (type === 'stream-start') {
-    console.log('[SW] 🟢 stream-start received, id:', id);
+    DEBUG && console.log('[SW] stream-start received, id:', id);
     const pending = pendingRequests.get(id);
     if (pending && pending.streamController) {
       // Store headers/status for the streaming response
       pending.streamData = data;
       pending.resolveHeaders(data);
-      console.log('[SW] 🟢 headers resolved for stream', id);
+      DEBUG && console.log('[SW] headers resolved for stream', id);
     } else {
-      console.log('[SW] 🔴 No pending request or controller for stream-start', id, !!pending, pending?.streamController);
+      DEBUG && console.log('[SW] No pending request or controller for stream-start', id, !!pending, pending?.streamController);
     }
   }
 
   if (type === 'stream-chunk') {
-    console.log('[SW] 🟡 stream-chunk received, id:', id, 'size:', data?.chunkBase64?.length);
+    DEBUG && console.log('[SW] stream-chunk received, id:', id, 'size:', data?.chunkBase64?.length);
     const pending = pendingRequests.get(id);
     if (pending && pending.streamController) {
       try {
         // Decode base64 chunk and enqueue
         if (data.chunkBase64) {
-          const binary = atob(data.chunkBase64);
-          const bytes = new Uint8Array(binary.length);
-          for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i);
-          }
+          const bytes = base64ToBytes(data.chunkBase64);
           pending.streamController.enqueue(bytes);
-          console.log('[SW] 🟡 chunk enqueued, bytes:', bytes.length);
+          DEBUG && console.log('[SW] chunk enqueued, bytes:', bytes.length);
         }
       } catch (e) {
         console.error('[SW] Error enqueueing chunk:', e);
       }
     } else {
-      console.log('[SW] 🔴 No pending request or controller for stream-chunk', id);
+      DEBUG && console.log('[SW] No pending request or controller for stream-chunk', id);
     }
   }
 
   if (type === 'stream-end') {
-    console.log('[SW] 🟢 stream-end received, id:', id);
+    DEBUG && console.log('[SW] stream-end received, id:', id);
     const pending = pendingRequests.get(id);
     if (pending && pending.streamController) {
       try {
         pending.streamController.close();
-        console.log('[SW] 🟢 stream closed');
+        DEBUG && console.log('[SW] stream closed');
       } catch (e) {
-        console.log('[SW] stream already closed');
+        DEBUG && console.log('[SW] stream already closed');
       }
       pendingRequests.delete(id);
     }
@@ -128,11 +141,23 @@ function handleMainMessage(event) {
  * Send request to main thread and wait for response
  */
 async function sendRequest(port, method, url, headers, body) {
-  console.log('[SW] sendRequest called, mainPort:', !!mainPort, 'url:', url);
+  DEBUG && console.log('[SW] sendRequest called, mainPort:', !!mainPort, 'url:', url);
 
   if (!mainPort) {
-    console.error('[SW] No mainPort available! Service Worker not connected to main thread.');
-    throw new Error('Service Worker not initialized - no connection to main thread');
+    // Ask all clients to re-send the init message
+    const allClients = await self.clients.matchAll({ type: 'window' });
+    for (const client of allClients) {
+      client.postMessage({ type: 'sw-needs-init' });
+    }
+    // Wait up to 5s for a client to re-initialize the port
+    // (main thread may be busy with heavy operations like CLI execution)
+    await new Promise(resolve => {
+      const check = setInterval(() => { if (mainPort) { clearInterval(check); resolve(); } }, 50);
+      setTimeout(() => { clearInterval(check); resolve(); }, 5000);
+    });
+    if (!mainPort) {
+      throw new Error('Service Worker not initialized - no connection to main thread');
+    }
   }
 
   const id = ++requestId;
@@ -160,11 +185,22 @@ async function sendRequest(port, method, url, headers, body) {
  * Send streaming request to main thread
  * Returns a ReadableStream that receives chunks from main thread
  */
-function sendStreamingRequest(port, method, url, headers, body) {
-  console.log('[SW] sendStreamingRequest called, url:', url);
+async function sendStreamingRequest(port, method, url, headers, body) {
+  DEBUG && console.log('[SW] sendStreamingRequest called, url:', url);
 
   if (!mainPort) {
-    throw new Error('Service Worker not initialized');
+    // Ask all clients to re-send the init message
+    const allClients = await self.clients.matchAll({ type: 'window' });
+    for (const client of allClients) {
+      client.postMessage({ type: 'sw-needs-init' });
+    }
+    await new Promise(resolve => {
+      const check = setInterval(() => { if (mainPort) { clearInterval(check); resolve(); } }, 50);
+      setTimeout(() => { clearInterval(check); resolve(); }, 5000);
+    });
+    if (!mainPort) {
+      throw new Error('Service Worker not initialized');
+    }
   }
 
   const id = ++requestId;
@@ -206,7 +242,7 @@ function sendStreamingRequest(port, method, url, headers, body) {
 self.addEventListener('fetch', (event) => {
   const url = new URL(event.request.url);
 
-  console.log('[SW] Fetch:', url.pathname, 'mainPort:', !!mainPort);
+  DEBUG && console.log('[SW] Fetch:', url.pathname, 'mainPort:', !!mainPort);
 
   // Check if this is a virtual server request
   const match = url.pathname.match(/^\/__virtual__\/(\d+)(\/.*)?$/);
@@ -229,12 +265,12 @@ self.addEventListener('fetch', (event) => {
           if (event.request.mode === 'navigate') {
             // Navigation requests: redirect to include the virtual prefix
             const redirectUrl = url.origin + virtualPrefix + targetPath;
-            console.log('[SW] Redirecting navigation from virtual context:', url.pathname, '->', redirectUrl);
+            DEBUG && console.log('[SW] Redirecting navigation from virtual context:', url.pathname, '->', redirectUrl);
             event.respondWith(Response.redirect(redirectUrl, 302));
             return;
           } else {
             // Non-navigation requests (images, scripts, etc.): forward to virtual server
-            console.log('[SW] Forwarding resource from virtual context:', url.pathname);
+            DEBUG && console.log('[SW] Forwarding resource from virtual context:', url.pathname);
             event.respondWith(handleVirtualRequest(event.request, virtualPort, targetPath));
             return;
           }
@@ -247,45 +283,11 @@ self.addEventListener('fetch', (event) => {
     return;
   }
 
-  console.log('[SW] Virtual request:', url.pathname);
+  DEBUG && console.log('[SW] Virtual request:', url.pathname);
 
   const port = parseInt(match[1], 10);
   const path = match[2] || '/';
 
-  // TEST MODE: Return hardcoded response to verify SW is working
-  if (url.searchParams.has('__sw_test__')) {
-    event.respondWith(new Response(
-      '<!DOCTYPE html><html><body><h1>SW Test OK</h1><div id="root">Service Worker is responding correctly!</div></body></html>',
-      {
-        status: 200,
-        headers: { 'Content-Type': 'text/html' },
-      }
-    ));
-    return;
-  }
-
-  // DEBUG MODE: Return info about what SW receives
-  if (url.searchParams.has('__sw_debug__')) {
-    event.respondWith((async () => {
-      try {
-        const response = await sendRequest(port, 'GET', path, {}, null);
-        return new Response(
-          `<!DOCTYPE html><html><body><h1>SW Debug</h1><pre>${JSON.stringify({
-            statusCode: response.statusCode,
-            statusMessage: response.statusMessage,
-            headers: response.headers,
-            bodyBase64Length: response.bodyBase64?.length,
-            bodyBase64Start: response.bodyBase64?.substring(0, 100),
-          }, null, 2)}</pre></body></html>`,
-          { status: 200, headers: { 'Content-Type': 'text/html' } }
-        );
-      } catch (error) {
-        return new Response(`Error: ${error.message}`, { status: 500 });
-      }
-    })());
-    return;
-  }
-
   event.respondWith(handleVirtualRequest(event.request, port, path + url.search));
 });
 
@@ -310,17 +312,15 @@ async function handleVirtualRequest(request, port, path) {
     const isStreamingCandidate = request.method === 'POST' && path.startsWith('/api/');
 
     if (isStreamingCandidate) {
-      console.log('[SW] 🔴 Using streaming mode for:', path);
+      DEBUG && console.log('[SW] Using streaming mode for:', path);
       return handleStreamingRequest(port, request.method, path, headers, body);
     }
-    console.log('[SW] Using non-streaming mode for:', request.method, path);
-
-    console.log('[SW] Sending request to main thread:', port, request.method, path);
+    DEBUG && console.log('[SW] Using non-streaming mode for:', request.method, path);
 
     // Send to main thread
     const response = await sendRequest(port, request.method, path, headers, body);
 
-    console.log('[SW] Got response from main thread:', {
+    DEBUG && console.log('[SW] Got response from main thread:', {
       statusCode: response.statusCode,
       headersKeys: response.headers ? Object.keys(response.headers) : [],
       bodyBase64Length: response.bodyBase64?.length,
@@ -330,16 +330,12 @@ async function handleVirtualRequest(request, port, path) {
     let finalResponse;
     if (response.bodyBase64 && response.bodyBase64.length > 0) {
       try {
-        const binary = atob(response.bodyBase64);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) {
-          bytes[i] = binary.charCodeAt(i);
-        }
-        console.log('[SW] Decoded body length:', bytes.length);
+        const bytes = base64ToBytes(response.bodyBase64);
+        DEBUG && console.log('[SW] Decoded body length:', bytes.length);
 
         // Use Blob to ensure proper body handling
         const blob = new Blob([bytes], { type: response.headers['Content-Type'] || 'application/octet-stream' });
-        console.log('[SW] Created blob size:', blob.size);
+        DEBUG && console.log('[SW] Created blob size:', blob.size);
 
         // Merge response headers with CORP/COEP headers to allow iframe embedding
         // The parent page has COEP: credentialless, so we need matching headers
@@ -370,7 +366,7 @@ async function handleVirtualRequest(request, port, path) {
       });
     }
 
-    console.log('[SW] Final Response created, status:', finalResponse.status);
+    DEBUG && console.log('[SW] Final Response created, status:', finalResponse.status);
 
     return finalResponse;
   } catch (error) {
@@ -387,12 +383,12 @@ async function handleVirtualRequest(request, port, path) {
  * Handle a streaming request
  */
 async function handleStreamingRequest(port, method, path, headers, body) {
-  const { stream, headersPromise, id } = sendStreamingRequest(port, method, path, headers, body);
+  const { stream, headersPromise, id } = await sendStreamingRequest(port, method, path, headers, body);
 
   // Wait for headers to arrive
   const responseData = await headersPromise;
 
-  console.log('[SW] Streaming response started:', responseData?.statusCode);
+  DEBUG && console.log('[SW] Streaming response started:', responseData?.statusCode);
 
   // Build response headers
   const respHeaders = new Headers(responseData?.headers || {});
@@ -412,7 +408,7 @@ async function handleStreamingRequest(port, method, path, headers, body) {
  * Activate immediately
  */
 self.addEventListener('install', (event) => {
-  console.log('[SW] Installing...');
+  DEBUG && console.log('[SW] Installing...');
   event.waitUntil(self.skipWaiting());
 });
 
@@ -420,6 +416,6 @@ self.addEventListener('install', (event) => {
  * Claim all clients immediately
  */
 self.addEventListener('activate', (event) => {
-  console.log('[SW] Activated');
+  DEBUG && console.log('[SW] Activated');
   event.waitUntil(self.clients.claim());
 });