nothing-browser 0.0.9 → 0.0.11

package/dist/register/index.js

@@ -16703,6 +16703,139 @@ function humanTypeSequence(text) {
   return actions;
 }
 
+// piggy/intercept/scripts.ts
+function buildRespondScript(pattern, status2, contentType, body) {
+  const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const safeBody = body.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  const safeContentType = contentType.replace(/'/g, "\\'");
+  return `
+(function() {
+  'use strict';
+  if (!window.__PIGGY_RESPOND_RULES__) window.__PIGGY_RESPOND_RULES__ = [];
+  window.__PIGGY_RESPOND_RULES__.push({
+    pattern: '${safePattern}',
+    status: ${status2},
+    contentType: '${safeContentType}',
+    body: \`${safeBody}\`
+  });
+
+  function _piggyMatchUrl(url, pattern) {
+    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
+    catch { return url.includes(pattern); }
+  }
+
+  // Only install wrappers once per page
+  if (window.__PIGGY_RESPOND_INSTALLED__) return;
+  window.__PIGGY_RESPOND_INSTALLED__ = true;
+
+  // ── fetch wrapper ──────────────────────────────────────────────────────────
+  const _origFetch = window.fetch;
+  window.fetch = function(input, init) {
+    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const rules = window.__PIGGY_RESPOND_RULES__ || [];
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) {
+        return Promise.resolve(new Response(rule.body, {
+          status: rule.status,
+          headers: { 'Content-Type': rule.contentType }
+        }));
+      }
+    }
+    return _origFetch.apply(this, arguments);
+  };
+
+  // ── XHR wrapper ────────────────────────────────────────────────────────────
+  const _origOpen = XMLHttpRequest.prototype.open;
+  const _origSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function(method, url) {
+    this.__piggy_url__ = String(url);
+    return _origOpen.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.send = function() {
+    const url = this.__piggy_url__ || '';
+    const rules = window.__PIGGY_RESPOND_RULES__ || [];
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) {
+        const self = this;
+        Object.defineProperty(self, 'readyState',   { get: () => 4,            configurable: true });
+        Object.defineProperty(self, 'status',       { get: () => rule.status,  configurable: true });
+        Object.defineProperty(self, 'responseText', { get: () => rule.body,    configurable: true });
+        Object.defineProperty(self, 'response',     { get: () => rule.body,    configurable: true });
+        setTimeout(() => {
+          if (typeof self.onreadystatechange === 'function') self.onreadystatechange();
+          self.dispatchEvent(new Event('readystatechange'));
+          self.dispatchEvent(new Event('load'));
+          self.dispatchEvent(new Event('loadend'));
+        }, 0);
+        return;
+      }
+    }
+    return _origSend.apply(this, arguments);
+  };
+})();
+`;
+}
+function buildModifyResponseScript(pattern, exposedFnName) {
+  const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const safeFnName = exposedFnName.replace(/'/g, "\\'");
+  return `
+(function() {
+  'use strict';
+  if (!window.__PIGGY_MODIFY_RULES__) window.__PIGGY_MODIFY_RULES__ = [];
+  window.__PIGGY_MODIFY_RULES__.push({ pattern: '${safePattern}', fn: '${safeFnName}' });
+
+  function _piggyMatchUrl(url, pattern) {
+    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
+    catch { return url.includes(pattern); }
+  }
+
+  // Only install wrappers once per page
+  if (window.__PIGGY_MODIFY_INSTALLED__) return;
+  window.__PIGGY_MODIFY_INSTALLED__ = true;
+
+  const _origFetch = window.fetch;
+  window.fetch = async function(input, init) {
+    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const rules = window.__PIGGY_MODIFY_RULES__ || [];
+
+    let matchedFn = null;
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) { matchedFn = rule.fn; break; }
+    }
+
+    // No match — pass through untouched
+    const resp = await _origFetch.apply(this, arguments);
+    if (!matchedFn) return resp;
+
+    try {
+      const bodyText = await resp.clone().text();
+      const headers  = {};
+      resp.headers.forEach((v, k) => { headers[k] = v; });
+
+      const handlerFn = window[matchedFn];
+      if (typeof handlerFn !== 'function') return resp;
+
+      // Call Node.js handler via exposeFunction bridge
+      const mod = await handlerFn({ body: bodyText, status: resp.status, headers });
+      if (!mod || typeof mod !== 'object' || Object.keys(mod).length === 0) return resp;
+
+      return new Response(
+        mod.body    !== undefined ? mod.body    : bodyText,
+        {
+          status:  mod.status  !== undefined ? mod.status  : resp.status,
+          headers: mod.headers !== undefined ? mod.headers : headers,
+        }
+      );
+    } catch {
+      return resp; // On any error, pass through original response
+    }
+  };
+})();
+`;
+}
+
 // piggy/register/index.ts
 var globalClient = null;
 var humanMode = false;
@@ -16729,6 +16862,20 @@ async function retry(label, fn, retries = 2, backoff = 150) {
 }
 function createSiteObject(name, registeredUrl, client, tabId) {
   let _currentUrl = registeredUrl;
+  const _eventListeners = new Map;
+  const _unsubNavigate = client.onEvent("navigate", tabId, (url) => {
+    _currentUrl = url;
+    const handlers = _eventListeners.get("navigate");
+    if (handlers) {
+      for (const h of handlers) {
+        try {
+          h(url);
+        } catch (e) {
+          logger_default.error(`[${name}] navigate handler error: ${e}`);
+        }
+      }
+    }
+  });
   const withErrScreen = async (fn, label) => {
     try {
       return await fn();
@@ -16743,6 +16890,7 @@ function createSiteObject(name, registeredUrl, client, tabId) {
       throw err;
     }
   };
+  let _modifyRuleCounter = 0;
   const site = {
     _name: name,
     _tabId: tabId,
@@ -16781,6 +16929,19 @@ function createSiteObject(name, registeredUrl, client, tabId) {
       logger_default.success(`[${name}] init script added`);
       return site;
     },
+    on: (event, handler) => {
+      if (!_eventListeners.has(event))
+        _eventListeners.set(event, new Set);
+      _eventListeners.get(event).add(handler);
+      logger_default.debug(`[${name}] on('${event}') registered`);
+      return () => {
+        _eventListeners.get(event)?.delete(handler);
+        logger_default.debug(`[${name}] on('${event}') unsubscribed`);
+      };
+    },
+    off: (event, handler) => {
+      _eventListeners.get(event)?.delete(handler);
+    },
     click: (selector, opts) => withErrScreen(() => retry(name, async () => {
       if (humanMode)
         await randomDelay(80, 220);
@@ -16914,6 +17075,86 @@ function createSiteObject(name, registeredUrl, client, tabId) {
         await client.addInterceptRule("modifyHeaders", pattern, { headers }, tabId);
         logger_default.info(`[${name}] intercept modifyHeaders: ${pattern}`);
       },
+      respond: async (pattern, handlerOrResponse) => {
+        const isStatic = typeof handlerOrResponse === "object";
+        const response = isStatic ? handlerOrResponse : { status: 200, contentType: "application/json", body: "" };
+        if (!isStatic) {
+          const fnName = `__piggy_respond_${name}_${++_modifyRuleCounter}__`;
+          await client.exposeFunction(fnName, async (req) => {
+            try {
+              const result = handlerOrResponse(req);
+              return {
+                success: true,
+                result: {
+                  status: result.status ?? 200,
+                  contentType: result.contentType ?? "application/json",
+                  body: result.body ?? ""
+                }
+              };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }, tabId);
+          const dynamicScript = `
+(function() {
+  'use strict';
+  if (!window.__PIGGY_DYNAMIC_RESPOND__) window.__PIGGY_DYNAMIC_RESPOND__ = [];
+  window.__PIGGY_DYNAMIC_RESPOND__.push({ pattern: ${JSON.stringify(pattern)}, fn: ${JSON.stringify(fnName)} });
+
+  function matchUrl(url, pattern) {
+    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
+    catch { return url.includes(pattern); }
+  }
+
+  if (window.__PIGGY_DYN_INSTALLED__) return;
+  window.__PIGGY_DYN_INSTALLED__ = true;
+
+  const _origFetch = window.fetch;
+  window.fetch = async function(input, init) {
+    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const method = (init?.method ?? 'GET').toUpperCase();
+    const rules = window.__PIGGY_DYNAMIC_RESPOND__ || [];
+    for (const rule of rules) {
+      if (matchUrl(url, rule.pattern) && typeof window[rule.fn] === 'function') {
+        try {
+          const r = await window[rule.fn]({ url, method });
+          return new Response(r.body ?? '', {
+            status: r.status ?? 200,
+            headers: { 'Content-Type': r.contentType ?? 'application/json' }
+          });
+        } catch { break; }
+      }
+    }
+    return _origFetch.apply(this, arguments);
+  };
+})();`;
+          await client.addInitScript(dynamicScript, tabId);
+          await client.evaluate(dynamicScript, tabId);
+          logger_default.success(`[${name}] intercept.respond (dynamic): ${pattern}`);
+          return site;
+        }
+        const script = buildRespondScript(pattern, response.status ?? 200, response.contentType ?? "application/json", response.body);
+        await client.addInitScript(script, tabId);
+        await client.evaluate(script, tabId);
+        logger_default.success(`[${name}] intercept.respond (static): ${pattern} → ${response.status ?? 200}`);
+        return site;
+      },
+      modifyResponse: async (pattern, handler) => {
+        const fnName = `__piggy_modres_${name}_${++_modifyRuleCounter}__`;
+        await client.exposeFunction(fnName, async (response) => {
+          try {
+            const mod = await handler(response);
+            return { success: true, result: mod ?? {} };
+          } catch (e) {
+            return { success: false, error: e.message };
+          }
+        }, tabId);
+        const script = buildModifyResponseScript(pattern, fnName);
+        await client.addInitScript(script, tabId);
+        await client.evaluate(script, tabId);
+        logger_default.success(`[${name}] intercept.modifyResponse: ${pattern}`);
+        return site;
+      },
       clear: async () => {
         await client.clearInterceptRules(tabId);
         logger_default.info(`[${name}] intercept rules cleared`);
@@ -16992,6 +17233,7 @@ function createSiteObject(name, registeredUrl, client, tabId) {
       return site;
     },
     close: async () => {
+      _unsubNavigate();
       keepAliveSites.delete(name);
       if (tabId !== "default") {
         await client.closeTab(tabId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothing-browser",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Browser automation library powered by Nothing Browser",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",