upload server

server/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "appletserver",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.7",
+    "dotenv": "^16.4.5",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.5.0",
+    "ws": "^8.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "nodemon": "^3.1.0"
+  }
+}

server/public/service-worker.js

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// service-worker.js
+
+// Define the target URL that we want to intercept and proxy.
+const TARGET_URL_PREFIX = 'https://generativelanguage.googleapis.com';
+
+// Installation event:
+self.addEventListener('install', (event) => {
+  try {
+    console.log('Service Worker: Installing...');
+    event.waitUntil(self.skipWaiting());
+  } catch (error) {
+    console.error('Service Worker: Error during install event:', error);
+    // If skipWaiting fails, the new SW might get stuck in a waiting state.
+  }
+});
+
+// Activation event:
+self.addEventListener('activate', (event) => {
+  try {
+    console.log('Service Worker: Activating...');
+    event.waitUntil(self.clients.claim());
+  } catch (error) {
+    console.error('Service Worker: Error during activate event:', error);
+    // If clients.claim() fails, the SW might not control existing pages until next nav.
+  }
+});
+
+// Fetch event:
+self.addEventListener('fetch', (event) => {
+  try {
+    const requestUrl = event.request.url;
+
+    if (requestUrl.startsWith(TARGET_URL_PREFIX)) {
+      console.log(`Service Worker: Intercepting request to ${requestUrl}`);
+
+      const remainingPathAndQuery = requestUrl.substring(TARGET_URL_PREFIX.length);
+      const proxyUrl = `${self.location.origin}/api-proxy${remainingPathAndQuery}`;
+
+      console.log(`Service Worker: Proxying to ${proxyUrl}`);
+
+      // Construct headers for the request to the proxy
+      const newHeaders = new Headers();
+      // Copy essential headers from the original request
+      // For OPTIONS (preflight) requests, Access-Control-Request-*  are critical.
+      // For actual requests (POST, GET), Content-Type, Accept etc.
+      const headersToCopy = [
+        'Content-Type',
+        'Accept',
+        'Access-Control-Request-Method',
+        'Access-Control-Request-Headers',
+      ];
+
+      for (const headerName of headersToCopy) {
+        if (event.request.headers.has(headerName)) {
+          newHeaders.set(headerName, event.request.headers.get(headerName));
+        }
+      }
+
+      if (event.request.method === 'POST') {
+
+        // Ensure Content-Type is set for POST requests to the proxy, defaulting to application/json
+        if (!newHeaders.has('Content-Type')) {
+          console.warn("Service Worker: POST request to proxy was missing Content-Type in newHeaders. Defaulting to application/json.");
+          newHeaders.set('Content-Type', 'application/json');
+        } else {
+          console.log(`Service Worker: POST request to proxy has Content-Type: ${newHeaders.get('Content-Type')}`);
+        }
+      }
+
+      const requestOptions = {
+        method: event.request.method,
+        headers: newHeaders, // Use simplified headers
+        body: event.request.body, // Still use the original body stream
+        mode: event.request.mode,
+        credentials: event.request.credentials,
+        cache: event.request.cache,
+        redirect: event.request.redirect,
+        referrer: event.request.referrer,
+        integrity: event.request.integrity,
+      };
+
+      // Only set duplex if there's a body and it's a relevant method
+      if (event.request.method !== 'GET' && event.request.method !== 'HEAD' && event.request.body ) {
+        requestOptions.duplex = 'half';
+      }
+
+      const promise = fetch(new Request(proxyUrl, requestOptions))
+        .then((response) => {
+          console.log(`Service Worker: Successfully proxied request to ${proxyUrl}, Status: ${response.status}`);
+          return response;
+        })
+        .catch((error) => {
+          // Log more error details
+          console.error(`Service Worker: Error proxying request to ${proxyUrl}. Message: ${error.message}, Name: ${error.name}, Stack: ${error.stack}`);
+          return new Response(
+            JSON.stringify({ error: 'Proxying failed', details: error.message, name: error.name, proxiedUrl: proxyUrl }),
+            {
+              status: 502, // Bad Gateway is appropriate for proxy errors
+              headers: { 'Content-Type': 'application/json' }
+            }
+          );
+        });
+
+      event.respondWith(promise);
+
+    } else {
+      // If the request URL doesn't match our target, let it proceed as normal.
+      event.respondWith(fetch(event.request));
+    }
+  } catch (error) {
+    // Log more error details for unhandled errors too
+    console.error('Service Worker: Unhandled error in fetch event handler. Message:', error.message, 'Name:', error.name, 'Stack:', error.stack);
+    event.respondWith(
+      new Response(
+        JSON.stringify({ error: 'Service worker fetch handler failed', details: error.message, name: error.name }),
+        {
+          status: 500,
+          headers: { 'Content-Type': 'application/json' }
+        }
+      )
+    );
+  }
+});

server/public/websocket-interceptor.js

@@ -0,0 +1,65 @@
+(function() {
+  const TARGET_WS_HOST = 'generativelanguage.googleapis.com'; // Host to intercept
+  const originalWebSocket = window.WebSocket;
+
+  if (!originalWebSocket) {
+    console.error('[WebSocketInterceptor] Original window.WebSocket not found. Cannot apply interceptor.');
+    return;
+  }
+
+  const handler = {
+    construct(target, args) {
+      let [url, protocols] = args;
+      //stringify url's if necessary for parsing
+      let newUrlString = typeof url === 'string' ? url : (url && typeof url.toString === 'function' ? url.toString() : null);
+      //get ready to check for host to proxy
+      let isTarget = false;
+
+      if (newUrlString) {
+        try {
+          // For full URLs, parse string and check the host
+          if (newUrlString.startsWith('ws://') || newUrlString.startsWith('wss://')) {
+            //URL object again
+            const parsedUrl = new URL(newUrlString);
+            if (parsedUrl.host === TARGET_WS_HOST) {
+              isTarget = true;
+              //use wss if https, else ws
+              const proxyScheme = window.location.protocol === 'https:' ? 'wss' : 'ws';
+              const proxyHost = window.location.host;
+              newUrlString = `${proxyScheme}://${proxyHost}/api-proxy${parsedUrl.pathname}${parsedUrl.search}`;
+            }
+          }
+        } catch (e) {
+          console.warn('[WebSocketInterceptor-Proxy] Error parsing WebSocket URL, using original:', url, e);
+        }
+      } else {
+          console.warn('[WebSocketInterceptor-Proxy] WebSocket URL is not a string or stringifiable. Using original.');
+      }
+
+      if (isTarget) {
+        console.log('[WebSocketInterceptor-Proxy] Original WebSocket URL:', url);
+        console.log('[WebSocketInterceptor-Proxy] Redirecting to proxy URL:', newUrlString);
+      }
+
+      // Call the original constructor with potentially modified arguments
+      // Reflect.construct ensures 'new target(...)' behavior and correct prototype chain
+      if (protocols) {
+        return Reflect.construct(target, [newUrlString, protocols]);
+      } else {
+        return Reflect.construct(target, [newUrlString]);
+      }
+    },
+    get(target, prop, receiver) {
+      // Forward static property access (e.g., WebSocket.OPEN, WebSocket.CONNECTING)
+      // and prototype access to the original WebSocket constructor/prototype
+      if (prop === 'prototype') {
+        return target.prototype;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  };
+
+  window.WebSocket = new Proxy(originalWebSocket, handler);
+
+  console.log('[WebSocketInterceptor-Proxy] Global WebSocket constructor has been wrapped using Proxy.');
+})();

server/server.js

@@ -0,0 +1,350 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+require('dotenv').config();
+const express = require('express');
+const fs = require('fs');
+const axios = require('axios');
+const https = require('https');
+const path = require('path');
+const WebSocket = require('ws');
+const { URLSearchParams, URL } = require('url');
+const rateLimit = require('express-rate-limit');
+
+const app = express();
+const port = process.env.PORT || 3000;
+const externalApiBaseUrl = 'https://generativelanguage.googleapis.com';
+const externalWsBaseUrl = 'wss://generativelanguage.googleapis.com';
+// Support either API key env-var variant
+const apiKey = process.env.GEMINI_API_KEY || process.env.API_KEY;
+
+const staticPath = path.join(__dirname,'dist');
+const publicPath = path.join(__dirname,'public');
+
+
+if (!apiKey) {
+    // Only log an error, don't exit. The server will serve apps without proxy functionality
+    console.error("Warning: GEMINI_API_KEY or API_KEY environment variable is not set! Proxy functionality will be disabled.");
+}
+else {
+  console.log("API KEY FOUND (proxy will use this)")
+}
+
+// Limit body size to 50mb
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({extended: true, limit: '50mb'}));
+app.set('trust proxy', 1 /* number of proxies between user and server */)
+
+// Rate limiter for the proxy
+const proxyLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // Set ratelimit window at 15min (in ms)
+    max: 100, // Limit each IP to 100 requests per window
+    message: 'Too many requests from this IP, please try again after 15 minutes',
+    standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
+    legacyHeaders: false, // no `X-RateLimit-*` headers
+    handler: (req, res, next, options) => {
+        console.warn(`Rate limit exceeded for IP: ${req.ip}. Path: ${req.path}`);
+        res.status(options.statusCode).send(options.message);
+    }
+});
+
+// Apply the rate limiter to the /api-proxy route before the main proxy logic
+app.use('/api-proxy', proxyLimiter);
+
+// Proxy route for Gemini API calls (HTTP)
+app.use('/api-proxy', async (req, res, next) => {
+    console.log(req.ip);
+    // If the request is an upgrade request, it's for WebSockets, so pass to next middleware/handler
+    if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') {
+        return next(); // Pass to the WebSocket upgrade handler
+    }
+
+    // Handle OPTIONS request for CORS preflight
+    if (req.method === 'OPTIONS') {
+        res.setHeader('Access-Control-Allow-Origin', '*'); // Adjust as needed for security
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Goog-Api-Key');
+        res.setHeader('Access-Control-Max-Age', '86400'); // Cache preflight response for 1 day
+        return res.sendStatus(200);
+    }
+
+    if (req.body) { // Only log body if it exists
+        console.log("  Request Body (from frontend):", req.body);
+    }
+    try {
+        // Construct the target URL by taking the part of the path after /api-proxy/
+        const targetPath = req.url.startsWith('/') ? req.url.substring(1) : req.url;
+        const apiUrl = `${externalApiBaseUrl}/${targetPath}`;
+        console.log(`HTTP Proxy: Forwarding request to ${apiUrl}`);
+
+        // Prepare headers for the outgoing request
+        const outgoingHeaders = {};
+        // Copy most headers from the incoming request
+        for (const header in req.headers) {
+            // Exclude host-specific headers and others that might cause issues upstream
+            if (!['host', 'connection', 'content-length', 'transfer-encoding', 'upgrade', 'sec-websocket-key', 'sec-websocket-version', 'sec-websocket-extensions'].includes(header.toLowerCase())) {
+                outgoingHeaders[header] = req.headers[header];
+            }
+        }
+
+        // Set the actual API key in the appropriate header
+        outgoingHeaders['X-Goog-Api-Key'] = apiKey;
+
+        // Set Content-Type from original request if present (for relevant methods)
+        if (req.headers['content-type'] && ['POST', 'PUT', 'PATCH'].includes(req.method.toUpperCase())) {
+            outgoingHeaders['Content-Type'] = req.headers['content-type'];
+        } else if (['POST', 'PUT', 'PATCH'].includes(req.method.toUpperCase())) {
+            // Default Content-Type to application/json if no content type for post/put/patch
+            outgoingHeaders['Content-Type'] = 'application/json';
+        }
+
+        // For GET or DELETE requests, ensure Content-Type is NOT sent,
+        // even if the client erroneously included it.
+        if (['GET', 'DELETE'].includes(req.method.toUpperCase())) {
+            delete outgoingHeaders['Content-Type']; // Case-sensitive common practice
+            delete outgoingHeaders['content-type']; // Just in case
+        }
+
+        // Ensure 'accept' is reasonable if not set
+        if (!outgoingHeaders['accept']) {
+            outgoingHeaders['accept'] = '*/*';
+        }
+
+
+        const axiosConfig = {
+            method: req.method,
+            url: apiUrl,
+            headers: outgoingHeaders,
+            responseType: 'stream',
+            validateStatus: function (status) {
+                return true; // Accept any status code, we'll pipe it through
+            },
+        };
+
+        if (['POST', 'PUT', 'PATCH'].includes(req.method.toUpperCase())) {
+            axiosConfig.data = req.body;
+        }
+        // For GET, DELETE, etc., axiosConfig.data will remain undefined,
+        // and axios will not send a request body.
+
+        const apiResponse = await axios(axiosConfig);
+
+        // Pass through response headers from Gemini API to the client
+        for (const header in apiResponse.headers) {
+            res.setHeader(header, apiResponse.headers[header]);
+        }
+        res.status(apiResponse.status);
+
+
+        apiResponse.data.on('data', (chunk) => {
+            res.write(chunk);
+        });
+
+        apiResponse.data.on('end', () => {
+            res.end();
+        });
+
+        apiResponse.data.on('error', (err) => {
+            console.error('Error during streaming data from target API:', err);
+            if (!res.headersSent) {
+                res.status(500).json({ error: 'Proxy error during streaming from target' });
+            } else {
+                // If headers already sent, we can't send a JSON error, just end the response.
+                res.end();
+            }
+        });
+
+    } catch (error) {
+        console.error('Proxy error before request to target API:', error);
+        if (!res.headersSent) {
+            if (error.response) {
+                const errorData = {
+                    status: error.response.status,
+                    message: error.response.data?.error?.message || 'Proxy error from upstream API',
+                    details: error.response.data?.error?.details || null
+                };
+                res.status(error.response.status).json(errorData);
+            } else {
+                res.status(500).json({ error: 'Proxy setup error', message: error.message });
+            }
+        }
+    }
+});
+
+const webSocketInterceptorScriptTag = `<script src="/public/websocket-interceptor.js" defer></script>`;
+
+// Prepare service worker registration script content
+const serviceWorkerRegistrationScript = `
+<script>
+if ('serviceWorker' in navigator) {
+  window.addEventListener('load' , () => {
+    navigator.serviceWorker.register('./service-worker.js')
+      .then(registration => {
+        console.log('Service Worker registered successfully with scope:', registration.scope);
+      })
+      .catch(error => {
+        console.error('Service Worker registration failed:', error);
+      });
+  });
+} else {
+  console.log('Service workers are not supported in this browser.');
+}
+</script>
+`;
+
+// Serve index.html or placeholder based on API key and file availability
+app.get('/', (req, res) => {
+    const placeholderPath = path.join(publicPath, 'placeholder.html');
+
+    // Try to serve index.html
+    console.log("LOG: Route '/' accessed. Attempting to serve index.html.");
+    const indexPath = path.join(staticPath, 'index.html');
+
+    fs.readFile(indexPath, 'utf8', (err, indexHtmlData) => {
+        if (err) {
+            // index.html not found or unreadable, serve the original placeholder
+            console.log('LOG: index.html not found or unreadable. Falling back to original placeholder.');
+            return res.sendFile(placeholderPath);
+        }
+
+        // If API key is not set, serve original HTML without injection
+        if (!apiKey) {
+          console.log("LOG: API key not set. Serving original index.html without script injections.");
+          return res.sendFile(indexPath);
+        }
+
+        // index.html found and apiKey set, inject scripts
+        console.log("LOG: index.html read successfully. Injecting scripts.");
+        let injectedHtml = indexHtmlData;
+
+
+        if (injectedHtml.includes('<head>')) {
+            // Inject WebSocket interceptor first, then service worker script
+            injectedHtml = injectedHtml.replace(
+                '<head>',
+                `<head>${webSocketInterceptorScriptTag}${serviceWorkerRegistrationScript}`
+            );
+            console.log("LOG: Scripts injected into <head>.");
+        } else {
+            console.warn("WARNING: <head> tag not found in index.html. Prepending scripts to the beginning of the file as a fallback.");
+            injectedHtml = `${webSocketInterceptorScriptTag}${serviceWorkerRegistrationScript}${indexHtmlData}`;
+        }
+        res.send(injectedHtml);
+    });
+});
+
+app.get('/service-worker.js', (req, res) => {
+   return res.sendFile(path.join(publicPath, 'service-worker.js'));
+});
+
+app.use('/public', express.static(publicPath));
+app.use(express.static(staticPath));
+
+// Start the HTTP server
+const server = app.listen(port, () => {
+    console.log(`Server listening on port ${port}`);
+    console.log(`HTTP proxy active on /api-proxy/**`);
+    console.log(`WebSocket proxy active on /api-proxy/**`);
+});
+
+// Create WebSocket server and attach it to the HTTP server
+const wss = new WebSocket.Server({ noServer: true });
+
+server.on('upgrade', (request, socket, head) => {
+    const requestUrl = new URL(request.url, `http://${request.headers.host}`);
+    const pathname = requestUrl.pathname;
+
+    if (pathname.startsWith('/api-proxy/')) {
+        if (!apiKey) {
+            console.error("WebSocket proxy: API key not configured. Closing connection.");
+            socket.destroy();
+            return;
+        }
+
+        wss.handleUpgrade(request, socket, head, (clientWs) => {
+            console.log('Client WebSocket connected to proxy for path:', pathname);
+
+            const targetPathSegment = pathname.substring('/api-proxy'.length);
+            const clientQuery = new URLSearchParams(requestUrl.search);
+            clientQuery.set('key', apiKey);
+            const targetGeminiWsUrl = `${externalWsBaseUrl}${targetPathSegment}?${clientQuery.toString()}`;
+            console.log(`Attempting to connect to target WebSocket: ${targetGeminiWsUrl}`);
+
+            const geminiWs = new WebSocket(targetGeminiWsUrl, {
+                protocol: request.headers['sec-websocket-protocol'],
+            });
+
+            const messageQueue = [];
+
+            geminiWs.on('open', () => {
+                console.log('Proxy connected to Gemini WebSocket');
+                // Send any queued messages
+                while (messageQueue.length > 0) {
+                    const message = messageQueue.shift();
+                    if (geminiWs.readyState === WebSocket.OPEN) {
+                        // console.log('Sending queued message from client -> Gemini');
+                        geminiWs.send(message);
+                    } else {
+                        // Should not happen if we are in 'open' event, but good for safety
+                        console.warn('Gemini WebSocket not open when trying to send queued message. Re-queuing.');
+                        messageQueue.unshift(message); // Add it back to the front
+                        break; // Stop processing queue for now
+                    }
+                }
+            });
+
+            geminiWs.on('message', (message) => {
+                // console.log('Message from Gemini -> client');
+                if (clientWs.readyState === WebSocket.OPEN) {
+                    clientWs.send(message);
+                }
+            });
+
+            geminiWs.on('close', (code, reason) => {
+                console.log(`Gemini WebSocket closed: ${code} ${reason.toString()}`);
+                if (clientWs.readyState === WebSocket.OPEN || clientWs.readyState === WebSocket.CONNECTING) {
+                    clientWs.close(code, reason.toString());
+                }
+            });
+
+            geminiWs.on('error', (error) => {
+                console.error('Error on Gemini WebSocket connection:', error);
+                if (clientWs.readyState === WebSocket.OPEN || clientWs.readyState === WebSocket.CONNECTING) {
+                    clientWs.close(1011, 'Upstream WebSocket error');
+                }
+            });
+
+            clientWs.on('message', (message) => {
+                if (geminiWs.readyState === WebSocket.OPEN) {
+                    // console.log('Message from client -> Gemini');
+                    geminiWs.send(message);
+                } else if (geminiWs.readyState === WebSocket.CONNECTING) {
+                    // console.log('Queueing message from client -> Gemini (Gemini still connecting)');
+                    messageQueue.push(message);
+                } else {
+                    console.warn('Client sent message but Gemini WebSocket is not open or connecting. Message dropped.');
+                }
+            });
+
+            clientWs.on('close', (code, reason) => {
+                console.log(`Client WebSocket closed: ${code} ${reason.toString()}`);
+                if (geminiWs.readyState === WebSocket.OPEN || geminiWs.readyState === WebSocket.CONNECTING) {
+                    geminiWs.close(code, reason.toString());
+                }
+            });
+
+            clientWs.on('error', (error) => {
+                console.error('Error on client WebSocket connection:', error);
+                if (geminiWs.readyState === WebSocket.OPEN || geminiWs.readyState === WebSocket.CONNECTING) {
+                    geminiWs.close(1011, 'Client WebSocket error');
+                }
+            });
+        });
+    } else {
+        console.log(`WebSocket upgrade request for non-proxy path: ${pathname}. Closing connection.`);
+        socket.destroy();
+    }
+});