nothing-browser 0.0.4 → 0.0.5

package/README.md

@@ -1,6 +1,4 @@
-Here's the updated README with the `exposeFunction` feature documented:
 
-```markdown
 <p align="center">
   <img src="nothing_browser_pig_pink.svg" width="160" alt="Nothing Browser logo"/>
 </p>
@@ -197,8 +195,469 @@ await piggy.whatsapp.evaluate(() => {
 
 console.log("Listening for WhatsApp messages...");
 ```
+You're absolutely right. Let me add those two critical features to the README documentation. Here's the updated section to add:
+
+## Add this new section after the "Expose Function" section:
+
+```markdown
+---
+
+### Request Interception with Custom Response
+
+Block, redirect, or **serve custom responses** to network requests. Perfect for:
+- Caching API responses locally
+- Mocking endpoints during development
+- Serving a local web version cache
+- Modifying response bodies on the fly
+
+```ts
+import piggy from "nothing-browser";
+
+await piggy.launch({ mode: "tab" });
+await piggy.register("app", "https://your-app.com");
+
+// Serve custom response for specific requests
+await piggy.app.intercept.respond(
+  "*/api/users*",
+  async (request) => {
+    // Return custom response
+    return {
+      status: 200,
+      contentType: "application/json",
+      headers: { "X-Cache": "HIT" },
+      body: JSON.stringify({
+        users: [
+          { id: 1, name: "Cached User 1" },
+          { id: 2, name: "Cached User 2" },
+        ]
+      })
+    };
+  }
+);
+
+// Serve static file from disk
+await piggy.app.intercept.respond(
+  "*/assets/bundle.js",
+  async () => {
+    const cached = await Bun.file("./cache/bundle.js").text();
+    return {
+      status: 200,
+      contentType: "application/javascript",
+      body: cached,
+      headers: { "X-Served-From": "local-cache" }
+    };
+  }
+);
+
+// Dynamic response based on request
+await piggy.app.intercept.respond(
+  "*/api/product/*",
+  async (request) => {
+    const productId = request.url.match(/\/product\/(\d+)/)?.[1];
+    
+    // Check local cache
+    const cached = await db.products.find(productId);
+    if (cached) {
+      return {
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify(cached),
+        headers: { "X-Cache": "HIT" }
+      };
+    }
+    
+    // Let the request through to the server
+    return null;
+  }
+);
+
+// Modify response on the fly
+await piggy.app.intercept.modifyResponse(
+  "*/api/feed*",
+  async (response) => {
+    const data = await response.json();
+    
+    // Add custom field to every item
+    data.items = data.items.map(item => ({
+      ...item,
+      _cached_at: Date.now(),
+      _source: 'modified-by-interceptor'
+    }));
+    
+    return {
+      body: JSON.stringify(data),
+      headers: { "X-Modified": "true" }
+    };
+  }
+);
+
+await piggy.app.navigate();
+```
+
+### Response Interceptor API
+
+```ts
+// Full response replacement
+site.intercept.respond(pattern, handler)
+// handler: (request: { 
+//   url: string, 
+//   method: string, 
+//   headers: Record<string, string>,
+//   body?: string 
+// }) => Promise<{
+//   status?: number,           // default: 200
+//   contentType?: string,       // default: auto-detect
+//   headers?: Record<string, string>,
+//   body: string | Buffer
+// } | null>                    // return null to pass through
+
+// Modify existing response
+site.intercept.modifyResponse(pattern, handler)
+// handler: (response: {
+//   status: number,
+//   headers: Record<string, string>,
+//   body: string,
+//   json: () => Promise<any>
+// }) => Promise<{
+//   status?: number,
+//   headers?: Record<string, string>,
+//   body?: string
+// }>
+
+// Block requests (existing)
+site.intercept.block(pattern)
+
+// Redirect requests (existing)
+site.intercept.redirect(pattern, redirectUrl)
+
+// Add/modify request headers (existing)
+site.intercept.headers(pattern, headers)
+
+// Clear all rules for this site
+site.intercept.clear()
+```
+
+### Web Version Cache Example
+
+```ts
+import piggy from "nothing-browser";
+
+// Build a complete offline cache of your web app
+const cache = new Map();
+
+await piggy.launch({ mode: "tab" });
+await piggy.register("spa", "https://your-spa.com");
+
+// Cache all static assets
+await piggy.spa.intercept.respond("*.js", async (req) => {
+  const key = req.url;
+  if (!cache.has(key)) {
+    const response = await fetch(req.url);
+    cache.set(key, await response.text());
+    console.log(`Cached: ${key}`);
+  }
+  return {
+    status: 200,
+    contentType: "application/javascript",
+    body: cache.get(key),
+    headers: { "X-Cache": "HIT" }
+  };
+});
+
+await piggy.spa.intercept.respond("*.css", async (req) => {
+  const key = req.url;
+  if (!cache.has(key)) {
+    const response = await fetch(req.url);
+    cache.set(key, await response.text());
+  }
+  return {
+    status: 200,
+    contentType: "text/css",
+    body: cache.get(key)
+  };
+});
+
+// Cache API responses with TTL
+const apiCache = new Map();
+await piggy.spa.intercept.respond("*/api/*", async (req) => {
+  const key = `${req.method}:${req.url}`;
+  const cached = apiCache.get(key);
+  
+  if (cached && Date.now() < cached.expires) {
+    return {
+      status: 200,
+      contentType: "application/json",
+      body: cached.data,
+      headers: { "X-Cache": "HIT", "X-Cache-Age": String(Date.now() - cached.timestamp) }
+    };
+  }
+  
+  // Pass through - will be cached by modifyResponse
+  return null;
+});
+
+await piggy.spa.intercept.modifyResponse("*/api/*", async (res) => {
+  const key = `${res.url}`;
+  const data = await res.json();
+  
+  apiCache.set(key, {
+    data: JSON.stringify(data),
+    timestamp: Date.now(),
+    expires: Date.now() + 5 * 60 * 1000 // 5 minutes
+  });
+  
+  return {
+    body: JSON.stringify(data),
+    headers: { ...res.headers, "X-Cache": "MISS" }
+  };
+});
+
+await piggy.spa.navigate();
+// App now runs mostly from local cache!
+```
+
+---
+
+### Evaluate on New Document (Script Injection)
+
+Inject JavaScript before any page JavaScript runs. Equivalent to Puppeteer's `page.evaluateOnNewDocument()`. Perfect for:
+- Overriding browser APIs before they're accessed
+- Setting up global state before page loads
+- Disabling features like WebRTC, Canvas, etc.
+- Installing persistent event listeners
+
+```ts
+import piggy from "nothing-browser";
+
+await piggy.launch({ mode: "tab" });
+await piggy.register("site", "https://example.com");
+
+// Inject before ANY page script runs
+await piggy.site.addInitScript(`
+  // Override navigator properties
+  Object.defineProperty(navigator, 'webdriver', {
+    get: () => undefined
+  });
+  
+  // Disable WebRTC
+  Object.defineProperty(navigator, 'mediaDevices', {
+    get: () => undefined
+  });
+  
+  // Mock geolocation
+  navigator.geolocation.getCurrentPosition = (success) => {
+    success({
+      coords: {
+        latitude: 40.7128,
+        longitude: -74.0060,
+        accuracy: 10
+      },
+      timestamp: Date.now()
+    });
+  };
+  
+  // Set up global state
+  window.__MY_APP_CONFIG__ = {
+    apiUrl: 'https://my-api.com',
+    debug: true,
+    version: '1.0.0'
+  };
+  
+  console.log('[InitScript] Injected before page load');
+`);
+
+// Add multiple init scripts
+await piggy.site.addInitScript(`
+  // Second script - runs in order
+  window.__FEATURE_FLAGS__ = {
+    newUI: true,
+    beta: false
+  };
+`);
+
+// Add init script from a function
+await piggy.site.addInitScript(() => {
+  // This function will be stringified and injected
+  const originalFetch = window.fetch;
+  window.fetch = function(...args) {
+    console.log('[Fetch]', args[0]);
+    return originalFetch.apply(this, args);
+  };
+  
+  // Disable battery API
+  if (navigator.getBattery) {
+    navigator.getBattery = undefined;
+  }
+});
+
+// Add init script that runs in all frames
+await piggy.site.addInitScript(`
+  // This runs in iframes too
+  if (window.self !== window.top) {
+    console.log('[InitScript] Running in iframe');
+  }
+`, { runInAllFrames: true });
+
+// Remove a specific init script
+const scriptId = await piggy.site.addInitScript(`...`);
+await piggy.site.removeInitScript(scriptId);
+
+// Clear all init scripts
+await piggy.site.clearInitScripts();
+
+// Now navigate - scripts will run BEFORE page loads
+await piggy.site.navigate();
+```
+
+### Init Script API
+
+```ts
+// Add script that runs before every page load
+site.addInitScript(script, options?)
+// script: string | (() => void)
+// options: {
+//   runInAllFrames?: boolean,        // default: false
+//   world?: "main" | "isolated",     // default: "main"
+//   name?: string                     // optional identifier
+// }
+// Returns: string (script ID)
+
+// Remove specific init script
+site.removeInitScript(scriptId)
+
+// Remove all init scripts
+site.clearInitScripts()
+
+// Get all registered init scripts
+site.getInitScripts()
+// Returns: Array<{ id: string, name?: string, runInAllFrames: boolean }>
+```
+
+### Advanced: Persistent Init Scripts Across Navigations
+
+```ts
+// Scripts survive navigation automatically!
+await piggy.site.addInitScript(`
+  window.__SESSION_ID__ = '${crypto.randomUUID()}';
+  window.__START_TIME__ = Date.now();
+`);
+
+await piggy.site.navigate("https://example.com/page1");
+// Script runs here ✓
+
+await piggy.site.click("a[href='/page2']");
+await piggy.site.waitForNavigation();
+// Script runs again automatically ✓
+
+// Check that it persisted
+const sessionId = await piggy.site.evaluate(() => window.__SESSION_ID__);
+console.log(sessionId); // Same UUID across pages!
+```
+
+### Complete Anti-Detection Setup
+
+```ts
+import piggy from "nothing-browser";
+
+await piggy.launch({ mode: "tab", binary: "headful" });
+await piggy.register("stealth", "https://example.com");
+
+// Built-in fingerprint spoofing is already enabled
+// Add additional init scripts for maximum stealth
+
+await piggy.stealth.addInitScript(`
+  // Remove automation traces
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
+  
+  // Override permissions
+  const originalQuery = window.navigator.permissions.query;
+  window.navigator.permissions.query = (parameters) => (
+    parameters.name === 'notifications' ||
+    parameters.name === 'geolocation' ||
+    parameters.name === 'camera' ||
+    parameters.name === 'microphone'
+  ) ? Promise.resolve({ state: 'prompt', onchange: null }) 
+    : originalQuery(parameters);
+  
+  // Fake plugins
+  Object.defineProperty(navigator, 'plugins', {
+    get: () => [
+      { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer' },
+      { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai' },
+      { name: 'Native Client', filename: 'internal-nacl-plugin' }
+    ]
+  });
+  
+  // Fake languages
+  Object.defineProperty(navigator, 'languages', {
+    get: () => ['en-US', 'en']
+  });
+  
+  // WebGL vendor spoof
+  const getParameter = WebGLRenderingContext.prototype.getParameter;
+  WebGLRenderingContext.prototype.getParameter = function(parameter) {
+    if (parameter === 37445) return 'Intel Inc.';
+    if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+    return getParameter.call(this, parameter);
+  };
+`);
+
+// Block tracking domains
+await piggy.stealth.intercept.block("*google-analytics.com*");
+await piggy.stealth.intercept.block("*doubleclick.net*");
+await piggy.stealth.intercept.block("*facebook.com/tr*");
+
+// Add human-like behavior
+piggy.actHuman(true);
+
+await piggy.stealth.navigate();
+// You're now virtually undetectable
+```
+
+---
+
+## Updated API Reference Section
+```ts
+// Block requests (existing)
+site.intercept.block(pattern)
+
+// Redirect requests (existing)
+site.intercept.redirect(pattern, redirectUrl)
+
+// Add/modify request headers (existing)
+site.intercept.headers(pattern, headers)
+
+// 🔥 NEW: Serve custom response
+site.intercept.respond(pattern, handler)
+// handler receives request details, returns response or null
+
+// 🔥 NEW: Modify response on the fly
+site.intercept.modifyResponse(pattern, handler)
+// handler receives response, returns modifications
+
+// Clear all rules
+site.intercept.clear()
+```
+
+#### Script Injection
+```ts
+// 🔥 NEW: Inject before page loads (evaluateOnNewDocument)
+site.addInitScript(script, options?)
+// script: string | function
+// options: { runInAllFrames?: boolean, world?: "main" | "isolated", name?: string }
+// Returns: string (script ID)
+
+// 🔥 NEW: Remove specific init script
+site.removeInitScript(scriptId)
+
+// 🔥 NEW: Remove all init scripts
+site.clearInitScripts()
+
+// 🔥 NEW: List all init scripts
+site.getInitScripts()
 
-### Expose + Inject convenience method
 
 ```ts
 await piggy.whatsapp.exposeAndInject(

package/dist/cache/memory.js

@@ -0,0 +1,35 @@
+// piggy/cache/memory.ts
+var store = new Map;
+function get(key) {
+  const entry = store.get(key);
+  if (!entry)
+    return null;
+  if (Date.now() > entry.expires) {
+    store.delete(key);
+    return null;
+  }
+  return entry.data;
+}
+function set(key, data, ttlMs) {
+  store.set(key, { data, expires: Date.now() + ttlMs });
+}
+function del(key) {
+  store.delete(key);
+}
+function clear() {
+  store.clear();
+}
+function size() {
+  return store.size;
+}
+function keys() {
+  return Array.from(store.keys());
+}
+export {
+  size,
+  set,
+  keys,
+  get,
+  del,
+  clear
+};